-
Crypto Intelligence Dashboard
-Live market data, AI-powered sentiment analysis, and comprehensive crypto intelligence
+
@@ -146,18 +184,37 @@
-
+
+ Top 10 Coins
+
+
+ Market Overview - 24H
+ +
+
+
+
+
+
Top Cryptocurrencies
+
-
+
| # | -Symbol | -Name | +Coin | Price | 24h % | -Volume | +7d % | Market Cap | +Volume | +Chart |
|---|---|---|---|---|---|---|---|---|---|---|
| # | +Coin | +Price | +24h Change | +7d Change | +Market Cap | +Volume (24h) | +Last 7 Days | +
|---|
+
+
+
+ Advanced Chart Analysis
+ Interactive +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Bitcoin (BTC) Price Chart
+
+ $0
+ 0%
+
+
+
+
+
+
+
+
+ Trading Volume
+
+
+
+
+
+
+ Compare Cryptocurrencies
+ Side by Side +
+
+
+
+
+
+ Compare up to 5 cryptocurrencies
+ Select coins to compare their performance side by side
+
+
+
+
+ Comparison Chart
+
+
+
+
+
+
+ Portfolio Tracker
+ +
+
+
+ No Portfolio Data
+
+ Start tracking your crypto portfolio by adding your first asset
+
+
+
+
+ Loading...
+
+ `;
+ }
+ },
+
+ showError(element, message) {
+ if (element) {
+ element.innerHTML = `
+
+ `;
+ }
+ },
+
+ debounce(func, wait) {
+ let timeout;
+ return function executedFunction(...args) {
+ const later = () => {
+ clearTimeout(timeout);
+ func(...args);
+ };
+ clearTimeout(timeout);
+ timeout = setTimeout(later, wait);
+ };
+ },
+};
+
+// ═══════════════════════════════════════════════════════════════════
+// VIEW MANAGER
+// ═══════════════════════════════════════════════════════════════════
+
+class ViewManager {
+ constructor() {
+ this.currentView = 'overview';
+ this.views = new Map();
+ this.init();
+ }
+
+ init() {
+ // Desktop navigation
+ document.querySelectorAll('.nav-tab-btn').forEach(btn => {
+ btn.addEventListener('click', (e) => {
+ const view = btn.dataset.view;
+ this.switchView(view);
+ });
+ });
+
+ // Mobile navigation
+ document.querySelectorAll('.mobile-nav-tab-btn').forEach(btn => {
+ btn.addEventListener('click', (e) => {
+ const view = btn.dataset.view;
+ this.switchView(view);
+ });
+ });
+ }
+
+ switchView(viewName) {
+ if (this.currentView === viewName) return;
+
+ // Hide all views
+ document.querySelectorAll('.view-section').forEach(section => {
+ section.classList.remove('active');
+ });
+
+ // Show selected view
+ const viewSection = document.getElementById(`view-${viewName}`);
+ if (viewSection) {
+ viewSection.classList.add('active');
+ }
+
+ // Update navigation buttons
+ document.querySelectorAll('.nav-tab-btn, .mobile-nav-tab-btn').forEach(btn => {
+ btn.classList.remove('active');
+ if (btn.dataset.view === viewName) {
+ btn.classList.add('active');
+ }
+ });
+
+ this.currentView = viewName;
+ console.log('[View] Switched to:', viewName);
+
+ // Trigger view-specific updates
+ this.triggerViewUpdate(viewName);
+ }
+
+ triggerViewUpdate(viewName) {
+ const event = new CustomEvent('viewChange', { detail: { view: viewName } });
+ document.dispatchEvent(event);
+ }
+}
+
+// ═══════════════════════════════════════════════════════════════════
+// DASHBOARD APPLICATION (Enhanced with Full Backend Integration)
+// ═══════════════════════════════════════════════════════════════════
+
+class DashboardApp {
+ constructor() {
+ this.ws = new WebSocketClient(CONFIG.WS_URL);
+ this.api = new APIClient(CONFIG.BACKEND_URL);
+ this.viewManager = new ViewManager();
+ this.updateInterval = null;
+ this.data = {
+ market: null,
+ sentiment: null,
+ trending: null,
+ news: [],
+ providers: [],
+ };
+ }
+
+ async init() {
+ console.log('[App] Initializing dashboard...');
+
+ // Connect WebSocket
+ this.ws.connect();
+ this.setupWebSocketHandlers();
+
+ // Setup UI handlers
+ this.setupUIHandlers();
+
+ // Load initial data
+ await this.loadInitialData();
+
+ // Start periodic updates
+ this.startPeriodicUpdates();
+
+ // Listen for view changes
+ document.addEventListener('viewChange', (e) => {
+ this.handleViewChange(e.detail.view);
+ });
+
+ console.log('[App] Dashboard initialized successfully');
+ }
+
+ setupWebSocketHandlers() {
+ this.ws.on('connected', (isConnected) => {
+ console.log('[App] WebSocket connection status:', isConnected);
+ });
+
+ this.ws.on('api_update', (data) => {
+ console.log('[App] API update received');
+ if (data.api_id === 'market_data' || data.service === 'market_data') {
+ this.handleMarketUpdate(data);
+ }
+ });
+
+ this.ws.on('market_update', (data) => {
+ console.log('[App] Market update received');
+ this.handleMarketUpdate(data);
+ });
+
+ this.ws.on('sentiment_update', (data) => {
+ console.log('[App] Sentiment update received');
+ this.handleSentimentUpdate(data);
+ });
+
+ this.ws.on('status_update', (data) => {
+ console.log('[App] Status update received');
+ if (data.status?.active_connections !== undefined) {
+ this.updateOnlineUsers(data.status.active_connections);
+ }
+ });
+ }
+
+ setupUIHandlers() {
+ // Theme toggle
+ const themeToggle = document.getElementById('theme-toggle');
+ if (themeToggle) {
+ themeToggle.addEventListener('click', () => this.toggleTheme());
+ }
+
+ // Notifications
+ const notificationsBtn = document.getElementById('notifications-btn');
+ const notificationsPanel = document.getElementById('notifications-panel');
+ const closeNotifications = document.getElementById('close-notifications');
+
+ if (notificationsBtn && notificationsPanel) {
+ notificationsBtn.addEventListener('click', () => {
+ notificationsPanel.classList.toggle('active');
+ });
+ }
+
+ if (closeNotifications && notificationsPanel) {
+ closeNotifications.addEventListener('click', () => {
+ notificationsPanel.classList.remove('active');
+ });
+ }
+
+ // Settings
+ const settingsBtn = document.getElementById('settings-btn');
+ const settingsModal = document.getElementById('settings-modal');
+ const closeSettings = document.getElementById('close-settings');
+
+ if (settingsBtn && settingsModal) {
+ settingsBtn.addEventListener('click', () => {
+ settingsModal.classList.add('active');
+ });
+ }
+
+ if (closeSettings && settingsModal) {
+ closeSettings.addEventListener('click', () => {
+ settingsModal.classList.remove('active');
+ });
+ }
+
+ // Refresh buttons
+ const refreshCoins = document.getElementById('refresh-coins');
+ if (refreshCoins) {
+ refreshCoins.addEventListener('click', () => this.loadMarketData());
+ }
+
+ const refreshProviders = document.getElementById('refresh-providers');
+ if (refreshProviders) {
+ refreshProviders.addEventListener('click', () => this.loadProviders());
+ }
+
+ // Floating stats minimize
+ const minimizeStats = document.getElementById('minimize-stats');
+ const floatingStats = document.getElementById('floating-stats');
+ if (minimizeStats && floatingStats) {
+ minimizeStats.addEventListener('click', () => {
+ floatingStats.classList.toggle('minimized');
+ });
+ }
+
+ // Global search
+ const globalSearch = document.getElementById('global-search');
+ if (globalSearch) {
+ globalSearch.addEventListener('input', Utils.debounce((e) => {
+ this.handleSearch(e.target.value);
+ }, CONFIG.RATE_LIMITS?.SEARCH_DEBOUNCE_MS || 300));
+ }
+
+ // AI Tools
+ this.setupAIToolHandlers();
+
+ // Market filters
+ const marketFilter = document.getElementById('market-filter');
+ if (marketFilter) {
+ marketFilter.addEventListener('change', (e) => {
+ this.filterMarket(e.target.value);
+ });
+ }
+ }
+
+ setupAIToolHandlers() {
+ const sentimentBtn = document.getElementById('sentiment-analysis-btn');
+ const summaryBtn = document.getElementById('news-summary-btn');
+ const predictionBtn = document.getElementById('price-prediction-btn');
+ const patternBtn = document.getElementById('pattern-detection-btn');
+
+ if (sentimentBtn) {
+ sentimentBtn.addEventListener('click', () => this.runSentimentAnalysis());
+ }
+
+ if (summaryBtn) {
+ summaryBtn.addEventListener('click', () => this.runNewsSummary());
+ }
+
+ if (predictionBtn) {
+ predictionBtn.addEventListener('click', () => this.runPricePrediction());
+ }
+
+ if (patternBtn) {
+ patternBtn.addEventListener('click', () => this.runPatternDetection());
+ }
+
+ const clearResults = document.getElementById('clear-results');
+ const aiResults = document.getElementById('ai-results');
+ if (clearResults && aiResults) {
+ clearResults.addEventListener('click', () => {
+ aiResults.style.display = 'none';
+ });
+ }
+ }
+
+ async loadInitialData() {
+ this.showLoadingOverlay(true);
+
+ try {
+ await Promise.all([
+ this.loadMarketData(),
+ this.loadSentimentData(),
+ this.loadNewsData(),
+ ]);
+ } catch (error) {
+ console.error('[App] Error loading initial data:', error);
+ }
+
+ this.showLoadingOverlay(false);
+ }
+
+ async loadMarketData() {
+ try {
+ const [stats, coins] = await Promise.all([
+ this.api.getMarketStats(),
+ this.api.getTopCoins(CONFIG.MAX_COINS_DISPLAY || 20)
+ ]);
+
+ this.data.market = { stats, coins };
+ const coinsList = coins?.coins || coins || [];
+
+ this.renderMarketStats(stats?.stats || stats);
+ this.renderCoinsTable(coinsList);
+ this.renderCoinsGrid(coinsList);
+ } catch (error) {
+ console.error('[App] Error loading market data:', error);
+ Utils.showError(document.getElementById('coins-table-body'), 'Failed to load market data');
+ }
+ }
+
+ async loadSentimentData() {
+ try {
+ const data = await this.api.getSentiment();
+ this.data.sentiment = data;
+ this.renderSentiment(data);
+ } catch (error) {
+ console.error('[App] Error loading sentiment data:', error);
+ }
+ }
+
+ async loadNewsData() {
+ try {
+ const data = await this.api.getNews(CONFIG.MAX_NEWS_DISPLAY || 20);
+ this.data.news = data.news || data || [];
+ this.renderNews(this.data.news);
+ } catch (error) {
+ console.error('[App] Error loading news data:', error);
+ }
+ }
+
+ async loadProviders() {
+ try {
+ const providers = await this.api.getProviders();
+ this.data.providers = providers.providers || providers || [];
+ this.renderProviders(this.data.providers);
+ } catch (error) {
+ console.error('[App] Error loading providers:', error);
+ }
+ }
+
+ renderMarketStats(data) {
+ // Main metrics (3 main cards)
+ const totalMarketCap = document.getElementById('total-market-cap');
+ const volume24h = document.getElementById('volume-24h');
+ const marketTrend = document.getElementById('market-trend');
+ const activeCryptos = document.getElementById('active-cryptocurrencies');
+ const marketsCount = document.getElementById('markets-count');
+ const fearGreed = document.getElementById('fear-greed-index');
+ const marketCapChange24h = document.getElementById('market-cap-change-24h');
+ const top10Share = document.getElementById('top10-share');
+ const btcPrice = document.getElementById('btc-price');
+ const ethPrice = document.getElementById('eth-price');
+
+ if (totalMarketCap && data?.total_market_cap) {
+ totalMarketCap.textContent = Utils.formatCurrency(data.total_market_cap);
+ const marketCapChange = document.getElementById('market-cap-change');
+ if (marketCapChange && data.market_cap_change_percentage_24h !== undefined) {
+ const changeEl = marketCapChange.querySelector('span');
+ if (changeEl) {
+ changeEl.textContent = Utils.formatPercent(data.market_cap_change_percentage_24h);
+ }
+ }
+ }
+
+ if (volume24h && data?.total_volume_24h) {
+ volume24h.textContent = Utils.formatCurrency(data.total_volume_24h);
+ const volumeChange = document.getElementById('volume-change');
+ if (volumeChange) {
+ // Volume change would need to be calculated or provided
+ }
+ }
+
+ if (marketTrend && data?.market_cap_change_percentage_24h !== undefined) {
+ const change = data.market_cap_change_percentage_24h;
+ marketTrend.textContent = change > 0 ? 'Bullish' : change < 0 ? 'Bearish' : 'Neutral';
+ const trendChangeEl = document.getElementById('trend-change');
+ if (trendChangeEl) {
+ const changeSpan = trendChangeEl.querySelector('span');
+ if (changeSpan) {
+ changeSpan.textContent = Utils.formatPercent(change);
+ }
+ }
+ }
+
+ // Additional metrics (if elements exist)
+ const activeCryptos = document.getElementById('active-cryptocurrencies');
+ const marketsCount = document.getElementById('markets-count');
+ const fearGreed = document.getElementById('fear-greed-index');
+ const marketCapChange24h = document.getElementById('market-cap-change-24h');
+ const top10Share = document.getElementById('top10-share');
+ const btcPrice = document.getElementById('btc-price');
+ const ethPrice = document.getElementById('eth-price');
+ const btcDominance = document.getElementById('btc-dominance');
+ const ethDominance = document.getElementById('eth-dominance');
+
+ if (activeCryptos && data?.active_cryptocurrencies) {
+ activeCryptos.textContent = Utils.formatNumber(data.active_cryptocurrencies);
+ }
+
+ if (marketsCount && data?.markets) {
+ marketsCount.textContent = Utils.formatNumber(data.markets);
+ }
+
+ if (fearGreed && data?.fear_greed_index !== undefined) {
+ fearGreed.textContent = data.fear_greed_index || 'N/A';
+ const fearGreedChange = document.getElementById('fear-greed-change');
+ if (fearGreedChange) {
+ const index = data.fear_greed_index || 50;
+ if (index >= 75) fearGreedChange.textContent = 'Extreme Greed';
+ else if (index >= 55) fearGreedChange.textContent = 'Greed';
+ else if (index >= 45) fearGreedChange.textContent = 'Neutral';
+ else if (index >= 25) fearGreedChange.textContent = 'Fear';
+ else fearGreedChange.textContent = 'Extreme Fear';
+ }
+ }
+
+ if (btcDominance && data?.btc_dominance) {
+ document.getElementById('btc-dominance').textContent = `${data.btc_dominance.toFixed(1)}%`;
+ }
+
+ if (ethDominance && data?.eth_dominance) {
+ ethDominance.textContent = `${data.eth_dominance.toFixed(1)}%`;
+ }
+ }
+
+ renderCoinsTable(coins) {
+ const tbody = document.getElementById('coins-table-body');
+ if (!tbody) return;
+
+ if (!coins || coins.length === 0) {
+ tbody.innerHTML = '
+ ${coin.symbol || coin.name}
+ ${coin.name || ''}
+
+ No data available
+
+
+ `;
+ }).join('');
+ }
+
+ renderSentiment(data) {
+ if (!data) return;
+
+ const bullish = data.bullish || 0;
+ const neutral = data.neutral || 0;
+ const bearish = data.bearish || 0;
+
+ const bullishPercent = document.getElementById('bullish-percent');
+ const neutralPercent = document.getElementById('neutral-percent');
+ const bearishPercent = document.getElementById('bearish-percent');
+
+ if (bullishPercent) bullishPercent.textContent = `${bullish}%`;
+ if (neutralPercent) neutralPercent.textContent = `${neutral}%`;
+ if (bearishPercent) bearishPercent.textContent = `${bearish}%`;
+
+ // Update progress bars
+ const progressBars = document.querySelectorAll('.sentiment-progress-bar');
+ progressBars.forEach(bar => {
+ if (bar.classList.contains('bullish')) {
+ bar.style.width = `${bullish}%`;
+ } else if (bar.classList.contains('neutral')) {
+ bar.style.width = `${neutral}%`;
+ } else if (bar.classList.contains('bearish')) {
+ bar.style.width = `${bearish}%`;
+ }
+ });
+ }
+
+ renderNews(news) {
+ const newsGrid = document.getElementById('news-grid');
+ if (!newsGrid) return;
+
+ if (!news || news.length === 0) {
+ newsGrid.innerHTML = '${symbol}
+ ${Utils.formatCurrency(coin.price || coin.current_price)}
+
+ ${change >= 0 ? `
+
+ ` : `
+
+ `}
+ ${Utils.formatPercent(change)}
+
+ No news available
'; + return; + } + + newsGrid.innerHTML = news.map(item => ` +
+ ${item.image ? `
` : ''}
+
+ `).join('');
+ }
+
+ renderProviders(providers) {
+ const providersGrid = document.getElementById('providers-grid');
+ if (!providersGrid) return;
+
+ if (!providers || providers.length === 0) {
+ providersGrid.innerHTML = '
+
+ ${item.title}
+ +${item.description || item.body || item.summary || ''}
+ ${item.url ? `Read More` : ''} +No providers available
'; + return; + } + + providersGrid.innerHTML = providers.map(provider => ` +
+
+ `).join('');
+ }
+
+ handleMarketUpdate(data) {
+ if (data.data) {
+ this.renderMarketStats(data.data);
+ if (data.data.cryptocurrencies || data.data.coins) {
+ this.renderCoinsTable(data.data.cryptocurrencies || data.data.coins);
+ }
+ }
+ }
+
+ handleSentimentUpdate(data) {
+ if (data.data) {
+ this.renderSentiment(data.data);
+ }
+ }
+
+ updateOnlineUsers(count) {
+ const activeUsersCount = document.getElementById('active-users-count');
+ if (activeUsersCount) {
+ activeUsersCount.textContent = count;
+ }
+ }
+
+ handleViewChange(view) {
+ console.log('[App] View changed to:', view);
+
+ // Load data for specific views
+ switch (view) {
+ case 'providers':
+ this.loadProviders();
+ break;
+ case 'news':
+ this.loadNewsData();
+ break;
+ case 'market':
+ this.loadMarketData();
+ break;
+ }
+ }
+
+ startPeriodicUpdates() {
+ this.updateInterval = setInterval(() => {
+ if (CONFIG.DEBUG?.ENABLE_CONSOLE_LOGS) {
+ console.log('[App] Periodic update triggered');
+ }
+ this.loadMarketData();
+ this.loadSentimentData();
+ }, CONFIG.UPDATE_INTERVAL || 30000);
+ }
+
+ stopPeriodicUpdates() {
+ if (this.updateInterval) {
+ clearInterval(this.updateInterval);
+ this.updateInterval = null;
+ }
+ }
+
+ toggleTheme() {
+ document.body.classList.toggle('light-theme');
+ const icon = document.querySelector('#theme-toggle i');
+ if (icon) {
+ icon.classList.toggle('fa-moon');
+ icon.classList.toggle('fa-sun');
+ }
+ }
+
+ handleSearch(query) {
+ console.log('[App] Search query:', query);
+ // Implement search functionality
+ }
+
+ filterMarket(filter) {
+ console.log('[App] Filter market:', filter);
+ // Implement filter functionality
+ }
+
+ viewCoinDetails(symbol) {
+ console.log('[App] View coin details:', symbol);
+ // Switch to charts view and load coin data
+ this.viewManager.switchView('charts');
+ }
+
+ showLoadingOverlay(show) {
+ const overlay = document.getElementById('loading-overlay');
+ if (overlay) {
+ if (show) {
+ overlay.classList.add('active');
+ } else {
+ overlay.classList.remove('active');
+ }
+ }
+ }
+
+ // AI Tool Methods
+ async runSentimentAnalysis() {
+ const aiResults = document.getElementById('ai-results');
+ const aiResultsContent = document.getElementById('ai-results-content');
+
+ if (!aiResults || !aiResultsContent) return;
+
+ aiResults.style.display = 'block';
+ aiResultsContent.innerHTML = ' Analyzing...';
+
+ try {
+ const data = await this.api.getSentiment();
+
+ aiResultsContent.innerHTML = `
+
+
+ ${provider.name || provider.provider_id}
+ ${provider.status || 'Unknown'} +
+
+ Category: ${provider.category || 'N/A'}
+ ${provider.latency_ms ? `Latency: ${provider.latency_ms}ms
` : ''} +
+
+ `;
+ } catch (error) {
+ aiResultsContent.innerHTML = `
+
+ `;
+ }
+ }
+
+ async runNewsSummary() {
+ const aiResults = document.getElementById('ai-results');
+ const aiResultsContent = document.getElementById('ai-results-content');
+
+ if (!aiResults || !aiResultsContent) return;
+
+ aiResults.style.display = 'block';
+ aiResultsContent.innerHTML = ' Summarizing...';
+
+ setTimeout(() => {
+ aiResultsContent.innerHTML = `
+ Sentiment Analysis Results
+
+
+
+
+ Bullish
+ ${data.bullish || 0}%
+
+
+ Neutral
+ ${data.neutral || 0}%
+
+
+ Bearish
+ ${data.bearish || 0}%
+ + ${data.summary || 'Market sentiment analysis based on aggregated data from multiple sources'} +
+
+
+ `;
+ }, 1000);
+ }
+
+ async runPricePrediction() {
+ const aiResults = document.getElementById('ai-results');
+ const aiResultsContent = document.getElementById('ai-results-content');
+
+ if (!aiResults || !aiResultsContent) return;
+
+ aiResults.style.display = 'block';
+ aiResultsContent.innerHTML = ' Predicting...';
+
+ setTimeout(() => {
+ aiResultsContent.innerHTML = `
+ News Summary
+News summarization feature will be available soon.
++ This feature uses Hugging Face models for text summarization. +
+
+
+ `;
+ }, 1000);
+ }
+
+ async runPatternDetection() {
+ const aiResults = document.getElementById('ai-results');
+ const aiResultsContent = document.getElementById('ai-results-content');
+
+ if (!aiResults || !aiResultsContent) return;
+
+ aiResults.style.display = 'block';
+ aiResultsContent.innerHTML = ' Detecting patterns...';
+
+ setTimeout(() => {
+ aiResultsContent.innerHTML = `
+ Price Prediction
+Price prediction feature will be available soon.
++ This feature uses machine learning models to predict price trends. +
+
+
+ `;
+ }, 1000);
+ }
+
+ destroy() {
+ this.stopPeriodicUpdates();
+ this.ws.disconnect();
+ console.log('[App] Dashboard destroyed');
+ }
+}
+
+// ═══════════════════════════════════════════════════════════════════
+// INITIALIZATION
+// ═══════════════════════════════════════════════════════════════════
+
+let app;
+
+document.addEventListener('DOMContentLoaded', () => {
+ console.log('[Main] DOM loaded, initializing application...');
+
+ app = new DashboardApp();
+ app.init();
+
+ // Make app globally accessible for debugging
+ window.app = app;
+
+ console.log('[Main] Application ready');
+});
+
+// Cleanup on page unload
+window.addEventListener('beforeunload', () => {
+ if (app) {
+ app.destroy();
+ }
+});
+
+// Handle visibility change to pause/resume updates
+document.addEventListener('visibilitychange', () => {
+ if (document.hidden) {
+ console.log('[Main] Page hidden, pausing updates');
+ if (app) app.stopPeriodicUpdates();
+ } else {
+ console.log('[Main] Page visible, resuming updates');
+ if (app) {
+ app.startPeriodicUpdates();
+ app.loadMarketData();
+ }
+ }
+});
+
+// Export for module usage
+export { DashboardApp, APIClient, WebSocketClient, Utils };
diff --git a/backend/__pycache__/__init__.cpython-313.pyc b/backend/__pycache__/__init__.cpython-313.pyc
index 74d767f547510fc8c6553a77367c1a0b43041112..87a758e207f0627ec35f9d3d2a3f020228c4238c 100644
Binary files a/backend/__pycache__/__init__.cpython-313.pyc and b/backend/__pycache__/__init__.cpython-313.pyc differ
diff --git a/backend/services/__pycache__/__init__.cpython-313.pyc b/backend/services/__pycache__/__init__.cpython-313.pyc
index bf137c40bc340223f9066965f3902389e2579288..df874a08400f3d72102cb08bce51aea34e86cca1 100644
Binary files a/backend/services/__pycache__/__init__.cpython-313.pyc and b/backend/services/__pycache__/__init__.cpython-313.pyc differ
diff --git a/backend/services/__pycache__/hf_registry.cpython-313.pyc b/backend/services/__pycache__/hf_registry.cpython-313.pyc
index 1ea2af8edc29afe2c0e2441faf1efa490f2f9801..6bab536dba433ebe202d1c76392fd674f9fa5cf0 100644
Binary files a/backend/services/__pycache__/hf_registry.cpython-313.pyc and b/backend/services/__pycache__/hf_registry.cpython-313.pyc differ
diff --git a/collectors/__pycache__/__init__.cpython-313.pyc b/collectors/__pycache__/__init__.cpython-313.pyc
index 3aeb10e78e9eb72f801ec54a056d412536bb1ad7..aa47cdfb104e0f5dc34381a5d6e7d5684cc364b8 100644
Binary files a/collectors/__pycache__/__init__.cpython-313.pyc and b/collectors/__pycache__/__init__.cpython-313.pyc differ
diff --git a/collectors/__pycache__/aggregator.cpython-313.pyc b/collectors/__pycache__/aggregator.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f50b06ddbda57e8602b44ae033e574e3e78ea1a3
Binary files /dev/null and b/collectors/__pycache__/aggregator.cpython-313.pyc differ
diff --git a/config.js b/config.js
index 34990f995fb9b11f39184c16e089744365a916cc..2e1f64486faf222a52051342592d0dc20315d074 100644
--- a/config.js
+++ b/config.js
@@ -1,146 +1,366 @@
/**
- * API Configuration for Crypto API Monitoring System
- * Automatically detects environment (localhost, HuggingFace Spaces, or custom deployment)
+ * ═══════════════════════════════════════════════════════════════════
+ * CONFIGURATION FILE
+ * Dashboard Settings - Easy Customization
+ * ═══════════════════════════════════════════════════════════════════
*/
-const CONFIG = (() => {
- // Detect if running on HuggingFace Spaces
- const isHuggingFaceSpaces = window.location.hostname.includes('hf.space') ||
- window.location.hostname.includes('huggingface.co');
-
- // Detect if running locally
- const isLocalhost = window.location.hostname === 'localhost' ||
- window.location.hostname === '127.0.0.1' ||
- window.location.hostname === '';
-
- // Get base API URL based on environment
- const getApiBaseUrl = () => {
- // If running on HuggingFace Spaces, use relative URLs
- if (isHuggingFaceSpaces) {
- return window.location.origin;
- }
+// 🔧 Main Backend Settings
+window.DASHBOARD_CONFIG = {
- // If running locally, use localhost with port 7860
- if (isLocalhost) {
- return 'http://localhost:7860';
- }
+ // ═══════════════════════════════════════════════════════════════
+ // API and WebSocket URLs
+ // ═══════════════════════════════════════════════════════════════
- // For custom deployments, use the current origin
- return window.location.origin;
- };
-
- // Get WebSocket URL based on environment
- const getWebSocketUrl = () => {
- const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
- const host = isLocalhost ? 'localhost:7860' : window.location.host;
- return `${protocol}//${host}`;
- };
-
- const API_BASE = getApiBaseUrl();
- const WS_BASE = getWebSocketUrl();
-
- return {
- // API Configuration
- API_BASE: API_BASE,
- WS_BASE: WS_BASE,
-
- // Environment flags
- IS_HUGGINGFACE_SPACES: isHuggingFaceSpaces,
- IS_LOCALHOST: isLocalhost,
-
- // API Endpoints
- ENDPOINTS: {
- // Health & Status
- HEALTH: `${API_BASE}/health`,
- API_INFO: `${API_BASE}/api-info`,
- STATUS: `${API_BASE}/api/status`,
-
- // Provider Management
- PROVIDERS: `${API_BASE}/api/providers`,
- CATEGORIES: `${API_BASE}/api/categories`,
-
- // Data Collection
- PRICES: `${API_BASE}/api/prices`,
- NEWS: `${API_BASE}/api/news`,
- SENTIMENT: `${API_BASE}/api/sentiment/current`,
- WHALES: `${API_BASE}/api/whales/transactions`,
-
- // HuggingFace Integration
- HF_HEALTH: `${API_BASE}/api/hf/health`,
- HF_REGISTRY: `${API_BASE}/api/hf/registry`,
- HF_SEARCH: `${API_BASE}/api/hf/search`,
- HF_REFRESH: `${API_BASE}/api/hf/refresh`,
- HF_RUN_SENTIMENT: `${API_BASE}/api/hf/run-sentiment`,
-
- // Monitoring
- LOGS: `${API_BASE}/api/logs`,
- ALERTS: `${API_BASE}/api/alerts`,
- SCHEDULER: `${API_BASE}/api/scheduler/status`,
-
- // Analytics
- ANALYTICS: `${API_BASE}/api/analytics/failures`,
- RATE_LIMITS: `${API_BASE}/api/rate-limits`,
- },
+ BACKEND_URL: window.location.origin || 'https://really-amin-datasourceforcryptocurrency.hf.space',
+ WS_URL: (window.location.origin || 'https://really-amin-datasourceforcryptocurrency.hf.space').replace('http://', 'ws://').replace('https://', 'wss://') + '/ws',
- // WebSocket Endpoints
- WEBSOCKETS: {
- MASTER: `${WS_BASE}/ws`,
- LIVE: `${WS_BASE}/ws/live`,
- DATA: `${WS_BASE}/ws/data`,
- MARKET_DATA: `${WS_BASE}/ws/market_data`,
- NEWS: `${WS_BASE}/ws/news`,
- SENTIMENT: `${WS_BASE}/ws/sentiment`,
- WHALE_TRACKING: `${WS_BASE}/ws/whale_tracking`,
- HEALTH: `${WS_BASE}/ws/health`,
- MONITORING: `${WS_BASE}/ws/monitoring`,
- HUGGINGFACE: `${WS_BASE}/ws/huggingface`,
- },
+ // ⏱️ Update Timing (milliseconds)
+ UPDATE_INTERVAL: 30000, // Every 30 seconds
+ CACHE_TTL: 60000, // 1 minute
+ HEARTBEAT_INTERVAL: 30000, // 30 seconds
+
+ // 🔄 Reconnection Settings
+ MAX_RECONNECT_ATTEMPTS: 5,
+ RECONNECT_DELAY: 3000, // 3 seconds
+
+ // ═══════════════════════════════════════════════════════════════
+ // Display Settings
+ // ═══════════════════════════════════════════════════════════════
+
+ // Number of items to display
+ MAX_COINS_DISPLAY: 20, // Number of coins in table
+ MAX_NEWS_DISPLAY: 20, // Number of news items
+ MAX_TRENDING_DISPLAY: 10, // Number of trending items
+
+ // Table settings
+ TABLE_ROWS_PER_PAGE: 10,
+
+ // ═══════════════════════════════════════════════════════════════
+ // Chart Settings
+ // ═══════════════════════════════════════════════════════════════
+
+ CHART: {
+ DEFAULT_SYMBOL: 'BTCUSDT',
+ DEFAULT_INTERVAL: '1h',
+ AVAILABLE_INTERVALS: ['1m', '5m', '15m', '1h', '4h', '1d'],
+ THEME: 'dark',
+ },
+
+ // ═══════════════════════════════════════════════════════════════
+ // AI Settings
+ // ═══════════════════════════════════════════════════════════════
+
+ AI: {
+ ENABLE_SENTIMENT: true,
+ ENABLE_NEWS_SUMMARY: true,
+ ENABLE_PRICE_PREDICTION: false, // Currently disabled
+ ENABLE_PATTERN_DETECTION: false, // Currently disabled
+ },
+
+ // ═══════════════════════════════════════════════════════════════
+ // Notification Settings
+ // ═══════════════════════════════════════════════════════════════
+
+ NOTIFICATIONS: {
+ ENABLE: true,
+ SHOW_PRICE_ALERTS: true,
+ SHOW_NEWS_ALERTS: true,
+ AUTO_DISMISS_TIME: 5000, // 5 seconds
+ },
+
+ // ═══════════════════════════════════════════════════════════════
+ // UI Settings
+ // ═══════════════════════════════════════════════════════════════
- // Utility Functions
- buildUrl: (path) => {
- return `${API_BASE}${path}`;
+ UI: {
+ DEFAULT_THEME: 'dark', // 'dark' or 'light'
+ ENABLE_ANIMATIONS: true,
+ ENABLE_SOUNDS: false,
+ LANGUAGE: 'en', // 'en' or 'fa'
+ RTL: false,
+ },
+
+ // ═══════════════════════════════════════════════════════════════
+ // Debug Settings
+ // ═══════════════════════════════════════════════════════════════
+
+ DEBUG: {
+ ENABLE_CONSOLE_LOGS: true,
+ ENABLE_PERFORMANCE_MONITORING: true,
+ SHOW_API_REQUESTS: true,
+ SHOW_WS_MESSAGES: false,
+ },
+
+ // ═══════════════════════════════════════════════════════════════
+ // Default Filters and Sorting
+ // ═══════════════════════════════════════════════════════════════
+
+ FILTERS: {
+ DEFAULT_MARKET_FILTER: 'all', // 'all', 'gainers', 'losers', 'trending'
+ DEFAULT_NEWS_FILTER: 'all', // 'all', 'bitcoin', 'ethereum', 'defi', 'nft'
+ DEFAULT_SORT: 'market_cap', // 'market_cap', 'volume', 'price', 'change'
+ SORT_ORDER: 'desc', // 'asc' or 'desc'
+ },
+
+ // ═══════════════════════════════════════════════════════════════
+ // API Endpoints (Optional - if your backend differs)
+ // ═══════════════════════════════════════════════════════════════
+
+ ENDPOINTS: {
+ HEALTH: '/api/health',
+ MARKET: '/api/market/stats',
+ MARKET_PRICES: '/api/market/prices',
+ COINS_TOP: '/api/coins/top',
+ COIN_DETAILS: '/api/coins',
+ TRENDING: '/api/trending',
+ SENTIMENT: '/api/sentiment',
+ SENTIMENT_ANALYZE: '/api/sentiment/analyze',
+ NEWS: '/api/news/latest',
+ NEWS_SUMMARIZE: '/api/news/summarize',
+ STATS: '/api/stats',
+ PROVIDERS: '/api/providers',
+ PROVIDER_STATUS: '/api/providers/status',
+ CHART_HISTORY: '/api/charts/price',
+ CHART_ANALYZE: '/api/charts/analyze',
+ OHLCV: '/api/ohlcv',
+ QUERY: '/api/query',
+ DATASETS: '/api/datasets/list',
+ MODELS: '/api/models/list',
+ HF_HEALTH: '/api/hf/health',
+ HF_REGISTRY: '/api/hf/registry',
+ SYSTEM_STATUS: '/api/system/status',
+ SYSTEM_CONFIG: '/api/system/config',
+ CATEGORIES: '/api/categories',
+ RATE_LIMITS: '/api/rate-limits',
+ LOGS: '/api/logs',
+ ALERTS: '/api/alerts',
+ },
+
+ // ═══════════════════════════════════════════════════════════════
+ // WebSocket Events
+ // ═══════════════════════════════════════════════════════════════
+
+ WS_EVENTS: {
+ MARKET_UPDATE: 'market_update',
+ SENTIMENT_UPDATE: 'sentiment_update',
+ NEWS_UPDATE: 'news_update',
+ STATS_UPDATE: 'stats_update',
+ PRICE_UPDATE: 'price_update',
+ API_UPDATE: 'api_update',
+ STATUS_UPDATE: 'status_update',
+ SCHEDULE_UPDATE: 'schedule_update',
+ CONNECTED: 'connected',
+ DISCONNECTED: 'disconnected',
+ },
+
+ // ═══════════════════════════════════════════════════════════════
+ // Display Formats
+ // ═══════════════════════════════════════════════════════════════
+
+ FORMATS: {
+ CURRENCY: {
+ LOCALE: 'en-US',
+ STYLE: 'currency',
+ CURRENCY: 'USD',
+ },
+ DATE: {
+ LOCALE: 'en-US',
+ OPTIONS: {
+ year: 'numeric',
+ month: 'long',
+ day: 'numeric',
+ hour: '2-digit',
+ minute: '2-digit',
+ },
},
+ },
+
+ // ═══════════════════════════════════════════════════════════════
+ // Rate Limiting
+ // ═══════════════════════════════════════════════════════════════
+
+ RATE_LIMITS: {
+ API_REQUESTS_PER_MINUTE: 60,
+ SEARCH_DEBOUNCE_MS: 300,
+ },
+
+ // ═══════════════════════════════════════════════════════════════
+ // Storage Settings
+ // ═══════════════════════════════════════════════════════════════
- buildWsUrl: (path) => {
- return `${WS_BASE}${path}`;
+ STORAGE: {
+ USE_LOCAL_STORAGE: true,
+ SAVE_PREFERENCES: true,
+ STORAGE_PREFIX: 'hts_dashboard_',
+ },
+};
+
+// ═══════════════════════════════════════════════════════════════════
+// Predefined Profiles
+// ═══════════════════════════════════════════════════════════════════
+
+window.DASHBOARD_PROFILES = {
+
+ // High Performance Profile
+ HIGH_PERFORMANCE: {
+ UPDATE_INTERVAL: 15000, // Faster updates
+ CACHE_TTL: 30000, // Shorter cache
+ ENABLE_ANIMATIONS: false, // No animations
+ MAX_COINS_DISPLAY: 50,
+ },
+
+ // Data Saver Profile
+ DATA_SAVER: {
+ UPDATE_INTERVAL: 60000, // Less frequent updates
+ CACHE_TTL: 300000, // Longer cache (5 minutes)
+ MAX_COINS_DISPLAY: 10,
+ MAX_NEWS_DISPLAY: 10,
+ },
+
+ // Presentation Profile
+ PRESENTATION: {
+ ENABLE_ANIMATIONS: true,
+ UPDATE_INTERVAL: 20000,
+ SHOW_API_REQUESTS: false,
+ ENABLE_CONSOLE_LOGS: false,
+ },
+
+ // Development Profile
+ DEVELOPMENT: {
+ DEBUG: {
+ ENABLE_CONSOLE_LOGS: true,
+ ENABLE_PERFORMANCE_MONITORING: true,
+ SHOW_API_REQUESTS: true,
+ SHOW_WS_MESSAGES: true,
},
+ UPDATE_INTERVAL: 10000,
+ },
+};
+
+// ═══════════════════════════════════════════════════════════════════
+// Helper Function to Change Profile
+// ═══════════════════════════════════════════════════════════════════
+
+window.applyDashboardProfile = function (profileName) {
+ if (window.DASHBOARD_PROFILES[profileName]) {
+ const profile = window.DASHBOARD_PROFILES[profileName];
+ Object.assign(window.DASHBOARD_CONFIG, profile);
+ console.log(`✅ Profile "${profileName}" applied`);
+
+ // Reload application with new settings
+ if (window.app) {
+ window.app.destroy();
+ window.app = new DashboardApp();
+ window.app.init();
+ }
+ } else {
+ console.error(`❌ Profile "${profileName}" not found`);
+ }
+};
+
+// ═══════════════════════════════════════════════════════════════════
+// Helper Function to Change Backend URL
+// ═══════════════════════════════════════════════════════════════════
+
+window.changeBackendURL = function (httpUrl, wsUrl) {
+ window.DASHBOARD_CONFIG.BACKEND_URL = httpUrl;
+ window.DASHBOARD_CONFIG.WS_URL = wsUrl || httpUrl.replace('https://', 'wss://').replace('http://', 'ws://') + '/ws';
+
+ console.log('✅ Backend URL changed:');
+ console.log(' HTTP:', window.DASHBOARD_CONFIG.BACKEND_URL);
+ console.log(' WS:', window.DASHBOARD_CONFIG.WS_URL);
+
+ // Reload application
+ if (window.app) {
+ window.app.destroy();
+ window.app = new DashboardApp();
+ window.app.init();
+ }
+};
+
+// ═══════════════════════════════════════════════════════════════════
+// Save Settings to LocalStorage
+// ═══════════════════════════════════════════════════════════════════
- // Fetch helper with error handling
- fetchJSON: async (url, options = {}) => {
- try {
- const response = await fetch(url, options);
- if (!response.ok) {
- throw new Error(`HTTP ${response.status}: ${response.statusText}`);
- }
- return await response.json();
- } catch (error) {
- console.error(`Fetch error for ${url}:`, error);
- throw error;
+window.saveConfig = function () {
+ if (window.DASHBOARD_CONFIG.STORAGE.USE_LOCAL_STORAGE) {
+ try {
+ const configString = JSON.stringify(window.DASHBOARD_CONFIG);
+ localStorage.setItem(
+ window.DASHBOARD_CONFIG.STORAGE.STORAGE_PREFIX + 'config',
+ configString
+ );
+ console.log('✅ Settings saved');
+ } catch (error) {
+ console.error('❌ Error saving settings:', error);
+ }
+ }
+};
+
+// ═══════════════════════════════════════════════════════════════════
+// Load Settings from LocalStorage
+// ═══════════════════════════════════════════════════════════════════
+
+window.loadConfig = function () {
+ if (window.DASHBOARD_CONFIG.STORAGE.USE_LOCAL_STORAGE) {
+ try {
+ const configString = localStorage.getItem(
+ window.DASHBOARD_CONFIG.STORAGE.STORAGE_PREFIX + 'config'
+ );
+ if (configString) {
+ const savedConfig = JSON.parse(configString);
+ Object.assign(window.DASHBOARD_CONFIG, savedConfig);
+ console.log('✅ Settings loaded');
}
- },
+ } catch (error) {
+ console.error('❌ Error loading settings:', error);
+ }
+ }
+};
- // POST helper
- postJSON: async (url, body = {}) => {
- return CONFIG.fetchJSON(url, {
- method: 'POST',
- headers: {
- 'Content-Type': 'application/json',
- },
- body: JSON.stringify(body),
- });
- },
- };
-})();
+// ═══════════════════════════════════════════════════════════════════
+// Auto-load Settings on Page Load
+// ═══════════════════════════════════════════════════════════════════
-// Export for use in modules (if needed)
-if (typeof module !== 'undefined' && module.exports) {
- module.exports = CONFIG;
+if (document.readyState === 'loading') {
+ document.addEventListener('DOMContentLoaded', () => {
+ window.loadConfig();
+ });
+} else {
+ window.loadConfig();
}
-// Log configuration on load (for debugging)
-console.log('🚀 Crypto API Monitor - Configuration loaded:', {
- environment: CONFIG.IS_HUGGINGFACE_SPACES ? 'HuggingFace Spaces' :
- CONFIG.IS_LOCALHOST ? 'Localhost' : 'Custom Deployment',
- apiBase: CONFIG.API_BASE,
- wsBase: CONFIG.WS_BASE,
-});
+// ═══════════════════════════════════════════════════════════════════
+// Console Usage Guide
+// ═══════════════════════════════════════════════════════════════════
+
+console.log(`
+╔═══════════════════════════════════════════════════════════════╗
+║ HTS CRYPTO DASHBOARD - CONFIGURATION ║
+╚═══════════════════════════════════════════════════════════════╝
+
+📋 Available Commands:
+
+1. Change Profile:
+ applyDashboardProfile('HIGH_PERFORMANCE')
+ applyDashboardProfile('DATA_SAVER')
+ applyDashboardProfile('PRESENTATION')
+ applyDashboardProfile('DEVELOPMENT')
+
+2. Change Backend:
+ changeBackendURL('https://your-backend.com')
+
+3. Save/Load Settings:
+ saveConfig()
+ loadConfig()
+
+4. View Current Settings:
+ console.log(DASHBOARD_CONFIG)
+
+5. Manual Settings Change:
+ DASHBOARD_CONFIG.UPDATE_INTERVAL = 20000
+ saveConfig()
+
+═══════════════════════════════════════════════════════════════════
+`);
diff --git a/hf_unified_server.py b/hf_unified_server.py
index 60a0aeef4ad93ccee85a2c6f71877fbe84996b1e..5ca9c4cb135c735accd0560b672a41ca1d70ea7d 100644
--- a/hf_unified_server.py
+++ b/hf_unified_server.py
@@ -432,8 +432,45 @@ async def get_market_overview():
raise HTTPException(status_code=503, detail="Unable to fetch market data")
# Calculate market stats
- total_market_cap = sum(p.get("market_cap", 0) or 0 for p in prices)
- total_volume = sum(p.get("total_volume", 0) or 0 for p in prices)
+ # Try multiple field names for market cap and volume
+ total_market_cap = 0
+ total_volume = 0
+
+ for p in prices:
+ # Try different field names for market cap
+ market_cap = (
+ p.get("market_cap") or
+ p.get("market_cap_usd") or
+ p.get("market_cap_rank") or # Sometimes this is the value
+ None
+ )
+ # If market_cap is not found, try calculating from price and supply
+ if not market_cap:
+ price = p.get("price") or p.get("current_price") or 0
+ supply = p.get("circulating_supply") or p.get("total_supply") or 0
+ if price and supply:
+ market_cap = float(price) * float(supply)
+
+ if market_cap:
+ try:
+ total_market_cap += float(market_cap)
+ except (TypeError, ValueError):
+ pass
+
+ # Try different field names for volume
+ volume = (
+ p.get("total_volume") or
+ p.get("volume_24h") or
+ p.get("volume_24h_usd") or
+ None
+ )
+ if volume:
+ try:
+ total_volume += float(volume)
+ except (TypeError, ValueError):
+ pass
+
+ logger.info(f"Market overview: {len(prices)} coins, total_market_cap={total_market_cap:,.0f}, total_volume={total_volume:,.0f}")
# Sort by 24h change
gainers = sorted(
@@ -872,6 +909,14 @@ async def hf_sentiment(payload: Union[List[str], Dict[str, Any]] = Body(...)):
# HTML Routes - Serve UI files
# ============================================================================
+@app.get("/favicon.ico")
+async def favicon():
+ """Serve favicon"""
+ favicon_path = WORKSPACE_ROOT / "static" / "favicon.ico"
+ if favicon_path.exists():
+ return FileResponse(favicon_path)
+ return JSONResponse({"status": "no favicon"}, status_code=404)
+
@app.get("/", response_class=HTMLResponse)
async def root():
"""Serve main admin dashboard (admin.html)"""
@@ -997,10 +1042,49 @@ async def get_coin_detail(symbol: str):
@app.get("/api/market/stats")
async def get_market_stats():
- overview = await get_market_overview()
- return {"success": True, "stats": {"total_market_cap": overview.get("global_market_cap", 0),
- "total_volume_24h": overview.get("global_volume", 0), "btc_dominance": overview.get("btc_dominance", 0),
- "eth_dominance": overview.get("eth_dominance", 0)}}
+ """Get global market statistics (duplicate endpoint - keeping for compatibility)"""
+ try:
+ overview = await get_market_overview()
+
+ # Calculate ETH dominance from prices if available
+ eth_dominance = 0
+ if overview.get("total_market_cap", 0) > 0:
+ try:
+ eth_prices = await fetch_coingecko_prices(symbols=["ETH"], limit=1)
+ if eth_prices and len(eth_prices) > 0:
+ eth_market_cap = eth_prices[0].get("market_cap", 0) or 0
+ eth_dominance = (eth_market_cap / overview.get("total_market_cap", 1)) * 100
+ except:
+ pass
+
+ return {
+ "success": True,
+ "stats": {
+ "total_market_cap": overview.get("total_market_cap", 0) or 0,
+ "total_volume_24h": overview.get("total_volume_24h", 0) or 0,
+ "btc_dominance": overview.get("btc_dominance", 0) or 0,
+ "eth_dominance": eth_dominance,
+ "active_cryptocurrencies": 10000,
+ "markets": 500,
+ "market_cap_change_24h": 0.0,
+ "timestamp": datetime.now().isoformat()
+ }
+ }
+ except Exception as e:
+ logger.error(f"Error in /api/market/stats (duplicate): {e}")
+ return {
+ "success": True,
+ "stats": {
+ "total_market_cap": 0,
+ "total_volume_24h": 0,
+ "btc_dominance": 0,
+ "eth_dominance": 0,
+ "active_cryptocurrencies": 0,
+ "markets": 0,
+ "market_cap_change_24h": 0.0,
+ "timestamp": datetime.now().isoformat()
+ }
+ }
@app.get("/api/news/latest")
async def get_latest_news(limit: int = Query(default=40, ge=1, le=100)):
@@ -1026,19 +1110,7 @@ async def summarize_news(item: Dict[str, Any] = Body(...)):
e = analyze_news_item(item)
return {"success": True, "summary": e.get("title", ""), "sentiment": e.get("sentiment", "neutral")}
-@app.get("/api/charts/price/{symbol}")
-async def get_price_chart(symbol: str, timeframe: str = Query(default="7d")):
- tf_map = {"1d": 24, "7d": 168, "30d": 720, "90d": 2160, "1y": 8760}
- history = await market_collector.get_price_history(symbol, hours=tf_map.get(timeframe, 168))
- data = [{"timestamp": p.get("timestamp", ""), "price": p.get("price", 0)} for p in history]
- return {"success": True, "symbol": symbol.upper(), "timeframe": timeframe, "data": data}
-
-@app.post("/api/charts/analyze")
-async def analyze_chart(payload: Dict[str, Any] = Body(...)):
- from ai_models import analyze_chart_points
- history = await market_collector.get_price_history(payload.get("symbol"), hours=168)
- analysis = analyze_chart_points(history, payload.get("indicators", []))
- return {"success": True, "symbol": payload.get("symbol"), "analysis": analysis}
+# Duplicate endpoints removed - using the improved versions below in CHARTS ENDPOINTS section
@app.post("/api/sentiment/analyze")
async def analyze_sentiment(payload: Dict[str, Any] = Body(...)):
@@ -1265,14 +1337,26 @@ async def get_coin_detail(symbol: str):
async def get_market_stats():
"""Get global market statistics"""
try:
- # Use existing endpoint
+ # Use existing endpoint - get_market_overview returns total_market_cap and total_volume_24h
overview = await get_market_overview()
+ # Calculate ETH dominance from prices if available
+ eth_dominance = 0
+ if overview.get("total_market_cap", 0) > 0:
+ # Try to get ETH market cap from top coins
+ try:
+ eth_prices = await fetch_coingecko_prices(symbols=["ETH"], limit=1)
+ if eth_prices and len(eth_prices) > 0:
+ eth_market_cap = eth_prices[0].get("market_cap", 0) or 0
+ eth_dominance = (eth_market_cap / overview.get("total_market_cap", 1)) * 100
+ except:
+ pass
+
stats = {
- "total_market_cap": overview.get("global_market_cap", 0),
- "total_volume_24h": overview.get("global_volume", 0),
- "btc_dominance": overview.get("btc_dominance", 0),
- "eth_dominance": overview.get("eth_dominance", 0),
+ "total_market_cap": overview.get("total_market_cap", 0) or 0,
+ "total_volume_24h": overview.get("total_volume_24h", 0) or 0,
+ "btc_dominance": overview.get("btc_dominance", 0) or 0,
+ "eth_dominance": eth_dominance,
"active_cryptocurrencies": 10000, # Approximate
"markets": 500, # Approximate
"market_cap_change_24h": 0.0,
@@ -1357,30 +1441,112 @@ async def summarize_news(item: Dict[str, Any] = Body(...)):
async def get_price_chart(symbol: str, timeframe: str = Query(default="7d")):
"""Get price chart data"""
try:
- # Map timeframe to hours
- timeframe_map = {"1d": 24, "7d": 168, "30d": 720, "90d": 2160, "1y": 8760}
- hours = timeframe_map.get(timeframe, 168)
+ # Clean and validate symbol
+ symbol = symbol.strip().upper()
+ if not symbol:
+ return JSONResponse(
+ status_code=400,
+ content={
+ "success": False,
+ "symbol": "",
+ "timeframe": timeframe,
+ "data": [],
+ "count": 0,
+ "error": "Symbol cannot be empty"
+ }
+ )
+
+ logger.info(f"Fetching price history for {symbol} with timeframe {timeframe}")
- price_history = await market_collector.get_price_history(symbol, hours=hours)
+ # market_collector.get_price_history expects timeframe as string, not hours
+ price_history = await market_collector.get_price_history(symbol, timeframe=timeframe)
+
+ if not price_history or len(price_history) == 0:
+ logger.warning(f"No price history returned for {symbol}")
+ return {
+ "success": True,
+ "symbol": symbol,
+ "timeframe": timeframe,
+ "data": [],
+ "count": 0,
+ "message": "No data available"
+ }
chart_data = []
for point in price_history:
+ # Handle different timestamp formats
+ timestamp = point.get("timestamp") or point.get("time") or point.get("date")
+ price = point.get("price") or point.get("close") or point.get("value") or 0
+
+ # Convert timestamp to ISO format if needed
+ if timestamp:
+ try:
+ # If it's already a string, use it
+ if isinstance(timestamp, str):
+ # Try to parse and format
+ try:
+ # Try ISO format first
+ dt = datetime.fromisoformat(timestamp.replace('Z', '+00:00'))
+ timestamp = dt.isoformat()
+ except:
+ try:
+ # Try other common formats
+ from dateutil import parser
+ dt = parser.parse(timestamp)
+ timestamp = dt.isoformat()
+ except:
+ pass
+ elif isinstance(timestamp, (int, float)):
+ # Unix timestamp
+ dt = datetime.fromtimestamp(timestamp)
+ timestamp = dt.isoformat()
+ except Exception as e:
+ logger.warning(f"Error parsing timestamp {timestamp}: {e}")
+
chart_data.append({
- "timestamp": point.get("timestamp", ""),
- "price": point.get("price", 0),
- "date": point.get("timestamp", "")
+ "timestamp": timestamp or "",
+ "time": timestamp or "",
+ "date": timestamp or "",
+ "price": float(price) if price else 0,
+ "close": float(price) if price else 0,
+ "value": float(price) if price else 0
})
+ logger.info(f"Returning {len(chart_data)} data points for {symbol}")
+
return {
"success": True,
- "symbol": symbol.upper(),
+ "symbol": symbol,
"timeframe": timeframe,
"data": chart_data,
"count": len(chart_data)
}
+ except CollectorError as e:
+ logger.error(f"Collector error in /api/charts/price/{symbol}: {e}", exc_info=True)
+ return JSONResponse(
+ status_code=200,
+ content={
+ "success": False,
+ "symbol": symbol.upper() if symbol else "",
+ "timeframe": timeframe,
+ "data": [],
+ "count": 0,
+ "error": str(e)
+ }
+ )
except Exception as e:
- logger.error(f"Error in /api/charts/price/{symbol}: {e}")
- raise HTTPException(status_code=503, detail=str(e))
+ logger.error(f"Error in /api/charts/price/{symbol}: {e}", exc_info=True)
+ return JSONResponse(
+ status_code=200,
+ content={
+ "success": False,
+ "symbol": symbol.upper() if symbol else "",
+ "timeframe": timeframe,
+ "data": [],
+ "count": 0,
+ "error": str(e)
+ }
+ )
@app.post("/api/charts/analyze")
@@ -1391,12 +1557,38 @@ async def analyze_chart(payload: Dict[str, Any] = Body(...)):
timeframe = payload.get("timeframe", "7d")
indicators = payload.get("indicators", [])
- # Get price data
- price_history = await market_collector.get_price_history(symbol, hours=168)
+ if not symbol:
+ return JSONResponse(
+ status_code=400,
+ content={"success": False, "error": "Symbol is required"}
+ )
+
+ symbol = symbol.strip().upper()
+ logger.info(f"Analyzing chart for {symbol} with timeframe {timeframe}")
+
+ # Get price data - use timeframe string, not hours
+ price_history = await market_collector.get_price_history(symbol, timeframe=timeframe)
+
+ if not price_history or len(price_history) == 0:
+ return {
+ "success": False,
+ "symbol": symbol,
+ "timeframe": timeframe,
+ "error": "No price data available for analysis"
+ }
# Analyze with AI
from ai_models import analyze_chart_points
- analysis = analyze_chart_points(price_history, indicators)
+ try:
+ analysis = analyze_chart_points(price_history, indicators)
+ except Exception as ai_error:
+ logger.error(f"AI analysis error: {ai_error}", exc_info=True)
+ # Return a basic analysis if AI fails
+ analysis = {
+ "direction": "neutral",
+ "summary": "Analysis unavailable",
+ "signals": []
+ }
return {
"success": True,
@@ -1404,9 +1596,18 @@ async def analyze_chart(payload: Dict[str, Any] = Body(...)):
"timeframe": timeframe,
"analysis": analysis
}
+ except CollectorError as e:
+ logger.error(f"Collector error in /api/charts/analyze: {e}", exc_info=True)
+ return JSONResponse(
+ status_code=200,
+ content={"success": False, "error": str(e)}
+ )
except Exception as e:
- logger.error(f"Error in /api/charts/analyze: {e}")
- return {"success": False, "error": str(e)}
+ logger.error(f"Error in /api/charts/analyze: {e}", exc_info=True)
+ return JSONResponse(
+ status_code=200,
+ content={"success": False, "error": str(e)}
+ )
# ===== SENTIMENT ENDPOINTS =====
diff --git a/index.html b/index.html
index b5784ce7fc4e197a18df930a84bc07cc446affa9..d788f3aaa685c192246f303c387024943fbdb5c1 100644
--- a/index.html
+++ b/index.html
@@ -1,1216 +1,765 @@
-
-
-
-
-
- Pattern Detection
+Pattern detection feature will be available soon.
++ This feature detects candlestick patterns and technical analysis indicators. +
+
-
-
-
-
-
-
+
+
+
+
+
+
+
-
-
-
-
- 🚀 Crypto API Monitor
-Real API diagnostics + market intelligence
-
-
- Connecting...
-
-
-
-
-
-
-
-
-
- Total APIs
-
- --
- Loading…
-
-
-
-
- Online
-
- --
- Loading…
-
-
-
-
- Avg Response
-
- --
- Loading…
-
-
-
-
- Last Update
-
- --
- Auto-refresh
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- Provider Overview
- -
-
-
-
-
- | Provider | Status | Response | Uptime |
|---|---|---|---|
| Loading providers… | |||
-
-
-
- Error Monitor
- -Gathering diagnostics…
-
-
-
-
-
-
-
- Health Trend
-
-
-
- Status Distribution
-
-
-
-
-
-
-
- Providers Detail
- -
-
-
-
-
-
-
-
-
- Global Stats
-
-
-
- Top Movers
-
-
-
-
- Top Assets
-
-
-
- | Rank | Name | Price | 24h | Market Cap |
|---|
-
-
-
- Trending Now
-
-
-
-
-
-
-
- Fear & Greed Index
Loading sentiment…
-
-
-
- DeFi TVL
-
-
-
- | Protocol | TVL | 24h | Chain |
|---|
-
-
-
-
-
-
-
- Latest Headlines
- -
-
-
-
-
-
- Resource Search
- Live search across providers + HuggingFace registry -
-
-
-
-
-
-
-
- Providers
- -
-
- Models
- -
-
- Datasets
- -
-
-
-
-
- Export & Backup
-
-
-
-
-
-
-
-
-
- - - -
- Import Provider
- - - -
+
+
+
+
+
+
+
+ HTS Dashboard
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Total Market Cap
+
+ $2.5T
+
+
+ +2.4%
+
+
+
+
+
+
+ 24h Volume
+
+ $125B
+
+
+ -1.2%
+
+
+
+
+
+ Market Trend
+
+ Bullish
+
+
+ +5.6%
+
+
+
+
+
+
+
+
+
+
+
+ Market Sentiment
+ + + AI Powered + +
+
+
+
+
+
+
+ Bullish
+ 45%
+
+
+
+
+
+
+
+
+
+ Neutral
+ 30%
+
+
+
+
+
+
+
+
+ Bearish
+ 25%
+
+
+
+
+
+
+
+
+
+ Top Cryptocurrencies
+ +
+
+
+
+
+ | Rank | +Name | +Price | +24h Change | +Volume | +Market Cap | +Actions | +
|---|---|---|---|---|---|---|
| + + Loading... + | +||||||
+
+
+ Cryptocurrency Market
+
+
+
+
+
+
+
+
+
+
+ Advanced Charts
+
+
+
+
+
+
+
+
+
+
+ Active Indicators
+
+
+
+
+
+
+ Latest News & Analysis
+
+
+
+
+
+
+
+
+
+
+ AI-Powered Analysis
+Advanced analytics powered by Hugging Face models
+
+
+
+
+
+
+
+
+ Sentiment Analysis
+Analyze market sentiment from news and social media
+ +
+
+
+
+ News Summarization
+Automatically summarize long news articles with AI
+ +
+
+
+
+ Price Prediction
+Predict price trends using ML models
+ +
+
+
+ Pattern Detection
+Detect candlestick patterns and technical analysis
+ +
+
+
+ Data Providers
+ +
+
+
+
+
+
+ API Explorer
+ +
+
+
+
+
+
+
+ Response
+Select an endpoint to test...+
+
+
+
+
+
+
+
+ System Stats
+ +
+
+
+
+
+
+ API Status
+
+
+ Online
+
+
+
+ Ping
+ --
+
+
+ Last Update
+ --
+
+
+
+
+
+
+
+
+ Notifications
+ +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/node_modules/.package-lock.json b/node_modules/.package-lock.json
new file mode 100644
index 0000000000000000000000000000000000000000..c6ce692e7e41e9c1844c05d4980c9af7f060879c
--- /dev/null
+++ b/node_modules/.package-lock.json
@@ -0,0 +1,48 @@
+{
+ "name": "crypto-api-resource-monitor",
+ "version": "1.0.0",
+ "lockfileVersion": 3,
+ "requires": true,
+ "packages": {
+ "node_modules/fast-check": {
+ "version": "3.23.2",
+ "resolved": "https://registry.npmjs.org/fast-check/-/fast-check-3.23.2.tgz",
+ "integrity": "sha512-h5+1OzzfCC3Ef7VbtKdcv7zsstUQwUDlYpUTvjeUsJAssPgLn7QzbboPtL5ro04Mq0rPOsMzl7q5hIbRs2wD1A==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "individual",
+ "url": "https://github.com/sponsors/dubzzz"
+ },
+ {
+ "type": "opencollective",
+ "url": "https://opencollective.com/fast-check"
+ }
+ ],
+ "license": "MIT",
+ "dependencies": {
+ "pure-rand": "^6.1.0"
+ },
+ "engines": {
+ "node": ">=8.0.0"
+ }
+ },
+ "node_modules/pure-rand": {
+ "version": "6.1.0",
+ "resolved": "https://registry.npmjs.org/pure-rand/-/pure-rand-6.1.0.tgz",
+ "integrity": "sha512-bVWawvoZoBYpp6yIoQtQXHZjmz35RSVHnUOTefl8Vcjr8snTPY1wnpSPMWekcFwbxI6gtmT7rSYPFvz71ldiOA==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "individual",
+ "url": "https://github.com/sponsors/dubzzz"
+ },
+ {
+ "type": "opencollective",
+ "url": "https://opencollective.com/fast-check"
+ }
+ ],
+ "license": "MIT"
+ }
+ }
+}
diff --git a/node_modules/fast-check/CHANGELOG.md b/node_modules/fast-check/CHANGELOG.md
new file mode 100644
index 0000000000000000000000000000000000000000..1653243c73f3e5b41072f6b13e8bb3538565105e
--- /dev/null
+++ b/node_modules/fast-check/CHANGELOG.md
@@ -0,0 +1,1039 @@
+# 3.23.2
+
+_Increased resiliency to poisoning_
+[[Code](https://github.com/dubzzz/fast-check/tree/v3.23.2)][[Diff](https://github.com/dubzzz/fast-check/compare/v3.23.1...v3.23.2)]
+
+## Fixes
+
+- ([PR#5469](https://github.com/dubzzz/fast-check/pull/5469)) Bug: Make `subarray` a bit more resilient to poisoning
+- ([PR#5468](https://github.com/dubzzz/fast-check/pull/5468)) Bug: Make `stringify` a bit more resilient to poisoning
+- ([PR#5515](https://github.com/dubzzz/fast-check/pull/5515)) Bug: Make depth retrieval more resilient to poisoning
+- ([PR#5516](https://github.com/dubzzz/fast-check/pull/5516)) Bug: Make `mapToConstant` a bit more resilient to poisoning
+- ([PR#5517](https://github.com/dubzzz/fast-check/pull/5517)) Bug: Make run details printer a bit more resilient to poisoning
+- ([PR#5518](https://github.com/dubzzz/fast-check/pull/5518)) Bug: Make `gen` a bit more resilient to poisoning
+- ([PR#5456](https://github.com/dubzzz/fast-check/pull/5456)) CI: Allow Bluesky calls from the blog
+- ([PR#5457](https://github.com/dubzzz/fast-check/pull/5457)) CI: Add Bluesky CDN as trustable source for images
+- ([PR#5410](https://github.com/dubzzz/fast-check/pull/5410)) Doc: Release note for 3.23.0
+- ([PR#5413](https://github.com/dubzzz/fast-check/pull/5413)) Doc: Update social links on footer
+- ([PR#5414](https://github.com/dubzzz/fast-check/pull/5414)) Doc: Drop Twitter badge from README
+- ([PR#5415](https://github.com/dubzzz/fast-check/pull/5415)) Doc: Add link to bluesky account in the header of the doc
+- ([PR#5453](https://github.com/dubzzz/fast-check/pull/5453)) Doc: AdventOfPBT event Day 1
+- ([PR#5454](https://github.com/dubzzz/fast-check/pull/5454)) Doc: Saving Christmas with nroken playground
+- ([PR#5455](https://github.com/dubzzz/fast-check/pull/5455)) Doc: Add links towards Bluesky from the AdventOfPBT
+- ([PR#5460](https://github.com/dubzzz/fast-check/pull/5460)) Doc: Advent Of PBT, day 2
+- ([PR#5461](https://github.com/dubzzz/fast-check/pull/5461)) Doc: Add linkt towards Bluesky comments
+- ([PR#5464](https://github.com/dubzzz/fast-check/pull/5464)) Doc: Add quick code snippet directly from the documentation
+- ([PR#5465](https://github.com/dubzzz/fast-check/pull/5465)) Doc: Quick CTA to our Advent of PBT event
+- ([PR#5467](https://github.com/dubzzz/fast-check/pull/5467)) Doc: Single line success message for the Advent of PBT
+- ([PR#5470](https://github.com/dubzzz/fast-check/pull/5470)) Doc: Notify fast-check.dev account
+- ([PR#5471](https://github.com/dubzzz/fast-check/pull/5471)) Doc: Advent of PBT, day 3
+- ([PR#5472](https://github.com/dubzzz/fast-check/pull/5472)) Doc: Add comments section on Advent of PBT, Day 3
+- ([PR#5474](https://github.com/dubzzz/fast-check/pull/5474)) Doc: Advent of PBT, day 4
+- ([PR#5477](https://github.com/dubzzz/fast-check/pull/5477)) Doc: Add comments section on Advent of PBT, Day 4
+- ([PR#5479](https://github.com/dubzzz/fast-check/pull/5479)) Doc: Advent of PBT Day 5
+- ([PR#5480](https://github.com/dubzzz/fast-check/pull/5480)) Doc: Advent of PBT Day 5, link to comments on Bluesky
+- ([PR#5481](https://github.com/dubzzz/fast-check/pull/5481)) Doc: Do not send new success pixels when advent solved once
+- ([PR#5482](https://github.com/dubzzz/fast-check/pull/5482)) Doc: Add a counter showing the number of times the puzzle got solved
+- ([PR#5489](https://github.com/dubzzz/fast-check/pull/5489)) Doc: Advent Of PBT, Day 6
+- ([PR#5490](https://github.com/dubzzz/fast-check/pull/5490)) Doc: Advent of PBT, comments on Day 6
+- ([PR#5493](https://github.com/dubzzz/fast-check/pull/5493)) Doc: Fix playground code of Day 6
+- ([PR#5495](https://github.com/dubzzz/fast-check/pull/5495)) Doc: Advent of PBT Day 7
+- ([PR#5496](https://github.com/dubzzz/fast-check/pull/5496)) Doc: Advent of PBT Day 7, comments section
+- ([PR#5497](https://github.com/dubzzz/fast-check/pull/5497)) Doc: Advent of PBT Day 8
+- ([PR#5498](https://github.com/dubzzz/fast-check/pull/5498)) Doc: Advent of PBT Day 8, comments section
+- ([PR#5501](https://github.com/dubzzz/fast-check/pull/5501)) Doc: Drop buggy "solved times" at the end of each advent
+- ([PR#5500](https://github.com/dubzzz/fast-check/pull/5500)) Doc: Advent of PBT Day 9
+- ([PR#5503](https://github.com/dubzzz/fast-check/pull/5503)) Doc: Add back buggy "solved times" at the end of each advent
+- ([PR#5505](https://github.com/dubzzz/fast-check/pull/5505)) Doc: Advent of PBT Day 10
+- ([PR#5510](https://github.com/dubzzz/fast-check/pull/5510)) Doc: Advent Of PBT Day 10, comments section
+- ([PR#5508](https://github.com/dubzzz/fast-check/pull/5508)) Doc: Advent Of PBT Day 11
+- ([PR#5507](https://github.com/dubzzz/fast-check/pull/5507)) Doc: Advent Of PBT Day 12
+- ([PR#5509](https://github.com/dubzzz/fast-check/pull/5509)) Doc: Advent Of PBT Day 13
+- ([PR#5523](https://github.com/dubzzz/fast-check/pull/5523)) Doc: Advent of PBT add comments sections on days 11 to 13
+
+# 3.23.1
+
+_Faster instantiation of internet-related arbitraries_
+[[Code](https://github.com/dubzzz/fast-check/tree/v3.23.1)][[Diff](https://github.com/dubzzz/fast-check/compare/v3.23.0...v3.23.1)]
+
+## Fixes
+
+- ([PR#5402](https://github.com/dubzzz/fast-check/pull/5402)) Performance: Faster instantiation of internet-related arbitraries
+
+# 3.23.0
+
+_Extend usages of string-units and increased performance_
+[[Code](https://github.com/dubzzz/fast-check/tree/v3.23.0)][[Diff](https://github.com/dubzzz/fast-check/compare/v3.22.0...v3.23.0)]
+
+## Features
+
+- ([PR#5366](https://github.com/dubzzz/fast-check/pull/5366)) Add support for string-`unit` on `object`/`anything` arbitrary
+- ([PR#5367](https://github.com/dubzzz/fast-check/pull/5367)) Add support for string-`unit` on `json` arbitrary
+- ([PR#5390](https://github.com/dubzzz/fast-check/pull/5390)) Add back strong unmapping capabilities to `string`
+
+## Fixes
+
+- ([PR#5327](https://github.com/dubzzz/fast-check/pull/5327)) Bug: Resist even more to external poisoning for `string`
+- ([PR#5368](https://github.com/dubzzz/fast-check/pull/5368)) Bug: Better support for poisoning on `stringMatching`
+- ([PR#5344](https://github.com/dubzzz/fast-check/pull/5344)) CI: Adapt some tests for Node v23
+- ([PR#5346](https://github.com/dubzzz/fast-check/pull/5346)) CI: Drop usages of `it.concurrent` due to Node 23 failing
+- ([PR#5363](https://github.com/dubzzz/fast-check/pull/5363)) CI: Move to Vitest for `examples/`
+- ([PR#5391](https://github.com/dubzzz/fast-check/pull/5391)) CI: Preview builds using `pkg.pr.new`
+- ([PR#5392](https://github.com/dubzzz/fast-check/pull/5392)) CI: Connect custom templates to `pkg.pr.new` previews
+- ([PR#5394](https://github.com/dubzzz/fast-check/pull/5394)) CI: Install dependencies before building changesets
+- ([PR#5396](https://github.com/dubzzz/fast-check/pull/5396)) CI: Proper commit name on changelogs
+- ([PR#5393](https://github.com/dubzzz/fast-check/pull/5393)) Clean: Drop unused `examples/jest.setup.js`
+- ([PR#5249](https://github.com/dubzzz/fast-check/pull/5249)) Doc: Release note for fast-check 3.22.0
+- ([PR#5369](https://github.com/dubzzz/fast-check/pull/5369)) Doc: Typo fix in model-based-testing.md
+- ([PR#5370](https://github.com/dubzzz/fast-check/pull/5370)) Doc: Add new contributor jamesbvaughan
+- ([PR#5383](https://github.com/dubzzz/fast-check/pull/5383)) Doc: Properly indent code snippets for the documentation
+- ([PR#5372](https://github.com/dubzzz/fast-check/pull/5372)) Performance: Faster `canShrinkWithoutContext` for constants
+- ([PR#5386](https://github.com/dubzzz/fast-check/pull/5386)) Performance: Faster generate process for `mapToConstant`
+- ([PR#5387](https://github.com/dubzzz/fast-check/pull/5387)) Performance: Faster tokenizer of strings
+- ([PR#5388](https://github.com/dubzzz/fast-check/pull/5388)) Performance: Faster initialization of `string` with faster slices
+- ([PR#5389](https://github.com/dubzzz/fast-check/pull/5389)) Performance: Faster initialization of `string` with pre-cached slices
+- ([PR#5371](https://github.com/dubzzz/fast-check/pull/5371)) Test: Add extra set of tests for `constant*`
+
+---
+
+# 3.22.0
+
+_Graphemes support on `fc.string`_
+[[Code](https://github.com/dubzzz/fast-check/tree/v3.22.0)][[Diff](https://github.com/dubzzz/fast-check/compare/v3.21.0...v3.22.0)]
+
+## Features
+
+- ([PR#5222](https://github.com/dubzzz/fast-check/pull/5222)) Support for grapheme on `fc.string`
+- ([PR#5233](https://github.com/dubzzz/fast-check/pull/5233)) Mark as deprecated most of char and string arbitraries
+- ([PR#5238](https://github.com/dubzzz/fast-check/pull/5238)) Deprecate `bigInt`'s alternatives
+
+## Fixes
+
+- ([PR#5237](https://github.com/dubzzz/fast-check/pull/5237)) CI: Drop TypeScript rc release channel
+- ([PR#5241](https://github.com/dubzzz/fast-check/pull/5241)) CI: Move to changeset
+- ([PR#5199](https://github.com/dubzzz/fast-check/pull/5199)) Doc: Publish release note for 3.21.0
+- ([PR#5240](https://github.com/dubzzz/fast-check/pull/5240)) Doc: Better `string`'s deprecation note in documentation
+- ([PR#5203](https://github.com/dubzzz/fast-check/pull/5203)) Refactor: Add missing types on exported
+
+---
+
+# 3.21.0
+
+_Support customisable versions on `uuid`_
+[[Code](https://github.com/dubzzz/fast-check/tree/v3.21.0)][[Diff](https://github.com/dubzzz/fast-check/compare/v3.20.0...v3.21.0)]
+
+## Features
+
+- ([PR#5172](https://github.com/dubzzz/fast-check/pull/5172)) Support UUID versions [1-15] on `uuidV`
+- ([PR#5189](https://github.com/dubzzz/fast-check/pull/5189)) Deprecate `uuidV` in favor of `uuid`
+- ([PR#5188](https://github.com/dubzzz/fast-check/pull/5188)) Customize versions directly from `uuid`
+
+## Fixes
+
+- ([PR#5190](https://github.com/dubzzz/fast-check/pull/5190)) CI: Support npm publish on other tags
+- ([PR#5124](https://github.com/dubzzz/fast-check/pull/5124)) Doc: Publish release note for 3.20.0
+- ([PR#5137](https://github.com/dubzzz/fast-check/pull/5137)) Doc: Add missing options in the documentation for `float` and `double`
+- ([PR#5142](https://github.com/dubzzz/fast-check/pull/5142)) Doc: Better width for stargazer badge in the documentation
+- ([PR#5143](https://github.com/dubzzz/fast-check/pull/5143)) Doc: Document Faker integration
+- ([PR#5144](https://github.com/dubzzz/fast-check/pull/5144)) Doc: Add support us page in our documentation
+
+---
+
+# 3.20.0
+
+_New arbitraries to alter shrinking capabilities_
+[[Code](https://github.com/dubzzz/fast-check/tree/v3.20.0)][[Diff](https://github.com/dubzzz/fast-check/compare/v3.19.0...v3.20.0)]
+
+## Features
+
+- ([PR#5047](https://github.com/dubzzz/fast-check/pull/5047)) Introduce new `fc.noShrink` arbitrary
+- ([PR#5050](https://github.com/dubzzz/fast-check/pull/5050)) Introduce new `fc.noBias` arbitrary
+- ([PR#5006](https://github.com/dubzzz/fast-check/pull/5006)) Add ability to limit shrink path
+- ([PR#5112](https://github.com/dubzzz/fast-check/pull/5112)) Simplify `limitShrink` before releasing
+
+## Fixes
+
+- ([PR#5013](https://github.com/dubzzz/fast-check/pull/5013)) CI: Drop verbosity flag at unpack step in CI
+- ([PR#5074](https://github.com/dubzzz/fast-check/pull/5074)) CI: Check types with multiple TypeScript
+- ([PR#5015](https://github.com/dubzzz/fast-check/pull/5015)) Doc: Release note for 3.19.0
+- ([PR#5016](https://github.com/dubzzz/fast-check/pull/5016)) Doc: Fix typo in the PR template
+- ([PR#4858](https://github.com/dubzzz/fast-check/pull/4858)) Doc: Update Getting Started section in docs
+- ([PR#5035](https://github.com/dubzzz/fast-check/pull/5035)) Doc: Remove duplicate paragraph in `your-first-race-condition-test.mdx`
+- ([PR#5048](https://github.com/dubzzz/fast-check/pull/5048)) Doc: Add new contributors cindywu and nmay231
+- ([PR#5097](https://github.com/dubzzz/fast-check/pull/5097)) Doc: Add warning on `noShrink`
+- ([PR#5121](https://github.com/dubzzz/fast-check/pull/5121)) Doc: Document integration with other test runners
+
+---
+
+# 3.19.0
+
+_New options to generate unicode strings on objects_
+[[Code](https://github.com/dubzzz/fast-check/tree/v3.19.0)][[Diff](https://github.com/dubzzz/fast-check/compare/v3.18.0...v3.19.0)]
+
+## Features
+
+- ([PR#5010](https://github.com/dubzzz/fast-check/pull/5010)) Add option to generate unicode values in `object`
+- ([PR#5011](https://github.com/dubzzz/fast-check/pull/5011)) Add option to generate unicode values in `json`
+
+## Fixes
+
+- ([PR#4981](https://github.com/dubzzz/fast-check/pull/4981)) Bug: Better interrupt between multiple versions
+- ([PR#4984](https://github.com/dubzzz/fast-check/pull/4984)) CI: Rework issue template
+- ([PR#4941](https://github.com/dubzzz/fast-check/pull/4941)) Doc: Publish release note for 3.18.0
+- ([PR#4982](https://github.com/dubzzz/fast-check/pull/4982)) Script: Shorter bump command
+
+---
+
+# 3.18.0
+
+_New options for floating point arbitraries_
+[[Code](https://github.com/dubzzz/fast-check/tree/v3.18.0)][[Diff](https://github.com/dubzzz/fast-check/compare/v3.17.2...v3.18.0)]
+
+## Features
+
+- ([PR#4917](https://github.com/dubzzz/fast-check/pull/4917)) Add option to produce non-integer on `double`
+- ([PR#4923](https://github.com/dubzzz/fast-check/pull/4923)) Add option to produce non-integer on `float`
+- ([PR#4935](https://github.com/dubzzz/fast-check/pull/4935)) Produce "//" in web paths
+
+## Fixes
+
+- ([PR#4924](https://github.com/dubzzz/fast-check/pull/4924)) CI: Enable more advanced TS flags
+- ([PR#4925](https://github.com/dubzzz/fast-check/pull/4925)) CI: Explicitly test against Node 22
+- ([PR#4926](https://github.com/dubzzz/fast-check/pull/4926)) CI: Stabilize tests of `double` on small ranges
+- ([PR#4921](https://github.com/dubzzz/fast-check/pull/4921)) Performance: More optimal `noInteger` on `double`
+- ([PR#4933](https://github.com/dubzzz/fast-check/pull/4933)) Script: Switch on more eslint rules
+- ([PR#4922](https://github.com/dubzzz/fast-check/pull/4922)) Test: Cover `noInteger` on `double` via integration layers
+
+---
+
+# 3.17.2
+
+_Directly reference the official documentation from NPM_
+[[Code](https://github.com/dubzzz/fast-check/tree/v3.17.2)][[Diff](https://github.com/dubzzz/fast-check/compare/v3.17.1...v3.17.2)]
+
+## Fixes
+
+- ([PR#4853](https://github.com/dubzzz/fast-check/pull/4853)) CI: Build doc with full git history
+- ([PR#4872](https://github.com/dubzzz/fast-check/pull/4872)) CI: Stop caching Jest on CI
+- ([PR#4852](https://github.com/dubzzz/fast-check/pull/4852)) Doc: Show last update time on doc
+- ([PR#4851](https://github.com/dubzzz/fast-check/pull/4851)) Doc: Add last modified date to sitemap
+- ([PR#4868](https://github.com/dubzzz/fast-check/pull/4868)) Doc: Enhance SEO for homepage
+- ([PR#4888](https://github.com/dubzzz/fast-check/pull/4888)) Doc: Add tutorial for PBT with Jest
+- ([PR#4901](https://github.com/dubzzz/fast-check/pull/4901)) Doc: Use official doc for npm homepage
+- ([PR#4866](https://github.com/dubzzz/fast-check/pull/4866)) Test: Safer rewrite of Poisoning E2E
+- ([PR#4871](https://github.com/dubzzz/fast-check/pull/4871)) Test: Move tests to Vitest
+- ([PR#4863](https://github.com/dubzzz/fast-check/pull/4863)) Test: Explicitely import from Vitest
+- ([PR#4873](https://github.com/dubzzz/fast-check/pull/4873)) Test: Move to v8 for coverage
+- ([PR#4875](https://github.com/dubzzz/fast-check/pull/4875)) Test: Better mock/spy cleaning
+
+# 3.17.1
+
+_Better interrupt CJS/MJS regarding types_
+[[Code](https://github.com/dubzzz/fast-check/tree/v3.17.1)][[Diff](https://github.com/dubzzz/fast-check/compare/v3.17.0...v3.17.1)]
+
+## Fixes
+
+- ([PR#4842](https://github.com/dubzzz/fast-check/pull/4842)) Bug: Fix dual-packages hazard and types incompatibility
+- ([PR#4836](https://github.com/dubzzz/fast-check/pull/4836)) Doc: Release note for 3.17.0
+- ([PR#4844](https://github.com/dubzzz/fast-check/pull/4844)) Doc: Add new contributor patroza
+
+# 3.17.0
+
+_Allow access to some internals details linked to the underlying random generator_
+[[Code](https://github.com/dubzzz/fast-check/tree/v3.17.0)][[Diff](https://github.com/dubzzz/fast-check/compare/v3.16.0...v3.17.0)]
+
+## Features
+
+- ([PR#4817](https://github.com/dubzzz/fast-check/pull/4817)) Expose internal state of the PRNG from `Random`
+
+## Fixes
+
+- ([PR#4781](https://github.com/dubzzz/fast-check/pull/4781)) Doc: Official release note of 3.16.0
+- ([PR#4799](https://github.com/dubzzz/fast-check/pull/4799)) Doc: Add more links in the footer
+- ([PR#4800](https://github.com/dubzzz/fast-check/pull/4800)) Doc: Better colors for footer and dark mode
+
+---
+
+# 3.16.0
+
+_Type assert on assertions linked to `fc.pre`_
+[[Code](https://github.com/dubzzz/fast-check/tree/v3.16.0)][[Diff](https://github.com/dubzzz/fast-check/compare/v3.15.1...v3.16.0)]
+
+## Features
+
+- ([PR#4709](https://github.com/dubzzz/fast-check/pull/4709)) Make `fc.pre` an assertion function
+
+## Fixes
+
+- ([PR#4736](https://github.com/dubzzz/fast-check/pull/4736)) Bug: Wrong logo ratio on small screen
+- ([PR#4747](https://github.com/dubzzz/fast-check/pull/4747)) CI: Deploy website on Netlify
+- ([PR#4751](https://github.com/dubzzz/fast-check/pull/4751)) CI: Drop configuration of GitHub Pages
+- ([PR#4756](https://github.com/dubzzz/fast-check/pull/4756)) CI: Make CI fail on invalid deploy
+- ([PR#4776](https://github.com/dubzzz/fast-check/pull/4776)) CI: Drop Google Analytics
+- ([PR#4769](https://github.com/dubzzz/fast-check/pull/4769)) Clean: Drop legacy patch on React 17
+- ([PR#4677](https://github.com/dubzzz/fast-check/pull/4677)) Doc: Add `jsonwebtoken` to track record
+- ([PR#4712](https://github.com/dubzzz/fast-check/pull/4712)) Doc: Fix console errors of website
+- ([PR#4713](https://github.com/dubzzz/fast-check/pull/4713)) Doc: Add extra spacing on top of CTA
+- ([PR#4730](https://github.com/dubzzz/fast-check/pull/4730)) Doc: Optimize image assets on homepage
+- ([PR#4732](https://github.com/dubzzz/fast-check/pull/4732)) Doc: Optimize SVG assets
+- ([PR#4735](https://github.com/dubzzz/fast-check/pull/4735)) Doc: Less layout shift with proper sizes
+- ([PR#4750](https://github.com/dubzzz/fast-check/pull/4750)) Doc: Add link to Netlify
+- ([PR#4754](https://github.com/dubzzz/fast-check/pull/4754)) Doc: Better assets on the homepage of the website
+- ([PR#4768](https://github.com/dubzzz/fast-check/pull/4768)) Doc: Add new contributors ej-shafran and gruhn
+- ([PR#4771](https://github.com/dubzzz/fast-check/pull/4771)) Doc: Blog post for 3.15.0
+- ([PR#4753](https://github.com/dubzzz/fast-check/pull/4753)) Security: Configure CSP for fast-check.dev
+- ([PR#4761](https://github.com/dubzzz/fast-check/pull/4761)) Security: Enforce Content-Security-Policy on our website
+- ([PR#4772](https://github.com/dubzzz/fast-check/pull/4772)) Security: Relax CSP policy to support Algolia
+
+---
+
+# 3.15.1
+
+_Prepare the monorepo for ESM build-chain_
+[[Code](https://github.com/dubzzz/fast-check/tree/v3.15.1)][[Diff](https://github.com/dubzzz/fast-check/compare/v3.15.0...v3.15.1)]
+
+## Fixes
+
+- ([PR#4591](https://github.com/dubzzz/fast-check/pull/4591)) CI: Move build chain to ESM for root of monorepo
+- ([PR#4598](https://github.com/dubzzz/fast-check/pull/4598)) CI: Add `onBrokenAnchors`'check on Docusaurus
+- ([PR#4606](https://github.com/dubzzz/fast-check/pull/4606)) CI: Configuration files for VSCode
+- ([PR#4650](https://github.com/dubzzz/fast-check/pull/4650)) CI: Move examples build chain to ESM
+- ([PR#4554](https://github.com/dubzzz/fast-check/pull/4554)) Doc: Add `idonttrustlikethat-fast-check` in ecosystem.md
+- ([PR#4563](https://github.com/dubzzz/fast-check/pull/4563)) Doc: Add new contributor nielk
+- ([PR#4669](https://github.com/dubzzz/fast-check/pull/4669)) Doc: Add `@effect/schema` in ecosystem
+- ([PR#4665](https://github.com/dubzzz/fast-check/pull/4665)) Test: Fix `isCorrect` check on double
+- ([PR#4666](https://github.com/dubzzz/fast-check/pull/4666)) Test: Stabilize flaky URL-related test
+
+# 3.15.0
+
+_Add support for `depthIdentifier` to `dictionary`_
+[[Code](https://github.com/dubzzz/fast-check/tree/v3.15.0)][[Diff](https://github.com/dubzzz/fast-check/compare/v3.14.0...v3.15.0)]
+
+## Features
+
+- ([PR#4548](https://github.com/dubzzz/fast-check/pull/4548)) Add support for `depthIdentifier` to `dictionary`
+
+## Fixes
+
+- ([PR#4502](https://github.com/dubzzz/fast-check/pull/4502)) Bug: Also produce null-prototype at root level of generated `object` when requested to
+- ([PR#4481](https://github.com/dubzzz/fast-check/pull/4481)) CI: Migrate configuration of Docusaurus to TS
+- ([PR#4463](https://github.com/dubzzz/fast-check/pull/4463)) Doc: Blog post for 3.14.0
+- ([PR#4464](https://github.com/dubzzz/fast-check/pull/4464)) Doc: Prefer import notation over require for README
+- ([PR#4482](https://github.com/dubzzz/fast-check/pull/4482)) Doc: Rework section on `waitAll` in the tutorial
+- ([PR#4477](https://github.com/dubzzz/fast-check/pull/4477)) Doc: Fix typo in date.md
+- ([PR#4494](https://github.com/dubzzz/fast-check/pull/4494)) Doc: Add new contributor bennettp123
+- ([PR#4541](https://github.com/dubzzz/fast-check/pull/4541)) Refactor: Rely on `dictionary` for `object` instead of inlined reimplementation
+- ([PR#4469](https://github.com/dubzzz/fast-check/pull/4469)) Test: More stable snapshot tests on stack traces
+- ([PR#4470](https://github.com/dubzzz/fast-check/pull/4470)) Test: Add cause flag onto snapshot tests checking stack traces
+- ([PR#4478](https://github.com/dubzzz/fast-check/pull/4478)) Test: Better snapshots tests implying stacktraces
+- ([PR#4483](https://github.com/dubzzz/fast-check/pull/4483)) Test: Wrap async no-regression snapshots within a sanitizer for stacktraces
+
+---
+
+# 3.14.0
+
+_Lighter import with less internals to load_
+[[Code](https://github.com/dubzzz/fast-check/tree/v3.14.0)][[Diff](https://github.com/dubzzz/fast-check/compare/v3.13.2...v3.14.0)]
+
+## Features
+
+- ([PR#4426](https://github.com/dubzzz/fast-check/pull/4426)) Prefer "import type" over raw "import"
+
+## Fixes
+
+- ([PR#4364](https://github.com/dubzzz/fast-check/pull/4364)) CI: Toggle more immutable on yarn
+- ([PR#4369](https://github.com/dubzzz/fast-check/pull/4369)) CI: Do not override existing on untar
+- ([PR#4372](https://github.com/dubzzz/fast-check/pull/4372)) CI: REVERT Do not override existing on untar
+- ([PR#4371](https://github.com/dubzzz/fast-check/pull/4371)) CI: Mark final check as failed and not skipped
+- ([PR#4375](https://github.com/dubzzz/fast-check/pull/4375)) CI: Attempt to patch untar step
+- ([PR#4378](https://github.com/dubzzz/fast-check/pull/4378)) CI: Attempt to patch untar step
+- ([PR#4380](https://github.com/dubzzz/fast-check/pull/4380)) CI: Add missing but directly called dependencies
+- ([PR#4384](https://github.com/dubzzz/fast-check/pull/4384)) CI: Attempt to patch untar step
+- ([PR#4368](https://github.com/dubzzz/fast-check/pull/4368)) CI: Attempt to switch to pnp linker
+- ([PR#4407](https://github.com/dubzzz/fast-check/pull/4407)) CI: No parallel "git" command
+- ([PR#4419](https://github.com/dubzzz/fast-check/pull/4419)) CI: Prefer "import type" via linter
+- ([PR#4428](https://github.com/dubzzz/fast-check/pull/4428)) CI: Default to Node 20 for CI
+- ([PR#4441](https://github.com/dubzzz/fast-check/pull/4441)) CI: Add support for PnP on VSCode
+- ([PR#4345](https://github.com/dubzzz/fast-check/pull/4345)) Performance: Faster replay: drop loose compare
+- ([PR#4381](https://github.com/dubzzz/fast-check/pull/4381)) Test: Import buffer via aliased name
+
+---
+
+# 3.13.2
+
+_Better reporting for invalid paths_
+[[Code](https://github.com/dubzzz/fast-check/tree/v3.13.2)][[Diff](https://github.com/dubzzz/fast-check/compare/v3.13.1...v3.13.2)]
+
+## Fixes
+
+- ([PR#4344](https://github.com/dubzzz/fast-check/pull/4344)) Bug: Path wrongly reported when invalid
+- ([PR#4279](https://github.com/dubzzz/fast-check/pull/4279)) CI: Better caching for yarn
+- ([PR#4346](https://github.com/dubzzz/fast-check/pull/4346)) CI: Better yarn caching in CI
+- ([PR#4347](https://github.com/dubzzz/fast-check/pull/4347)) CI: Avoid yarn install on "cache hit"
+- ([PR#4348](https://github.com/dubzzz/fast-check/pull/4348)) CI: Create job to confirm all passed
+- ([PR#4352](https://github.com/dubzzz/fast-check/pull/4352)) CI: Skip install on hot cache (win/mac)
+- ([PR#4299](https://github.com/dubzzz/fast-check/pull/4299)) Doc: Article around Zod vulnerability
+- ([PR#4306](https://github.com/dubzzz/fast-check/pull/4306)) Doc: Fixing a typos in Zod article
+- ([PR#4307](https://github.com/dubzzz/fast-check/pull/4307)) Doc: Add missing robots.txt
+- ([PR#4356](https://github.com/dubzzz/fast-check/pull/4356)) Doc: Better document limitations of `gen`
+- ([PR#4338](https://github.com/dubzzz/fast-check/pull/4338)) Script: Faster tests execution with babel
+- ([PR#4270](https://github.com/dubzzz/fast-check/pull/4270)) Test: Check tsc import and types of bundled package
+- ([PR#4271](https://github.com/dubzzz/fast-check/pull/4271)) Test: Typecheck ESM bundle correctly
+- ([PR#4269](https://github.com/dubzzz/fast-check/pull/4269)) Test: Rework checks against legacy node
+
+# 3.13.1
+
+_Fix typings for node native esm_
+[[Code](https://github.com/dubzzz/fast-check/tree/v3.13.1)][[Diff](https://github.com/dubzzz/fast-check/compare/v3.13.0...v3.13.1)]
+
+## Fixes
+
+- ([PR#4261](https://github.com/dubzzz/fast-check/pull/4261)) Bug: Fix typings for node native esm
+- ([PR#4230](https://github.com/dubzzz/fast-check/pull/4230)) Doc: Release note for 3.13.0
+- ([PR#4240](https://github.com/dubzzz/fast-check/pull/4240)) Doc: Some tips on prototype pollution
+- ([PR#4246](https://github.com/dubzzz/fast-check/pull/4246)) Doc: Fix typo in "Detect prototype pollution automatically"
+
+# 3.13.0
+
+_New options for `date`, `record` and `dictionary`_
+[[Code](https://github.com/dubzzz/fast-check/tree/v3.13.0)][[Diff](https://github.com/dubzzz/fast-check/compare/v3.12.1...v3.13.0)]
+
+## Features
+
+- ([PR#4197](https://github.com/dubzzz/fast-check/pull/4197)) Add support for "Invalid Date" in `date`
+- ([PR#4203](https://github.com/dubzzz/fast-check/pull/4203)) Deprecate `withDeletedKeys` on `record`
+- ([PR#4204](https://github.com/dubzzz/fast-check/pull/4204)) Support null-proto in `dictionary`
+- ([PR#4205](https://github.com/dubzzz/fast-check/pull/4205)) Support null-proto in `record`
+
+## Fixes
+
+- ([PR#4207](https://github.com/dubzzz/fast-check/pull/4207)) Bug: Better poisoning resiliency for `dictionary`
+- ([PR#4194](https://github.com/dubzzz/fast-check/pull/4194)) CI: Add some more details onto the PWA
+- ([PR#4211](https://github.com/dubzzz/fast-check/pull/4211)) CI: Rework broken test on `date`
+- ([PR#4212](https://github.com/dubzzz/fast-check/pull/4212)) CI: Rework broken test on `date` (retry)
+- ([PR#4214](https://github.com/dubzzz/fast-check/pull/4214)) CI: Rework another broken test on date
+- ([PR#4186](https://github.com/dubzzz/fast-check/pull/4186)) Doc: Document our approach to dual package
+- ([PR#4187](https://github.com/dubzzz/fast-check/pull/4187)) Doc: Expose website as PWA too
+- ([PR#4190](https://github.com/dubzzz/fast-check/pull/4190)) Move: Move the manifest in /static
+- ([PR#4206](https://github.com/dubzzz/fast-check/pull/4206)) Refactor: Re-use null-proto helpers of `dictionary` on `anything`
+- ([PR#4189](https://github.com/dubzzz/fast-check/pull/4189)) Test: Drop Node 14.x from the test-chain
+
+---
+
+# 3.12.1
+
+_Better support for types on ESM targets_
+[[Code](https://github.com/dubzzz/fast-check/tree/v3.12.1)][[Diff](https://github.com/dubzzz/fast-check/compare/v3.12.0...v3.12.1)]
+
+## Fixes
+
+- ([PR#4172](https://github.com/dubzzz/fast-check/pull/4172)) Bug: Better declare ESM's types
+- ([PR#4177](https://github.com/dubzzz/fast-check/pull/4177)) Bug: Replace macros in published esm types
+- ([PR#4156](https://github.com/dubzzz/fast-check/pull/4156)) CI: Stop formatting built website
+- ([PR#4155](https://github.com/dubzzz/fast-check/pull/4155)) CI: Add TypeScript checks on website
+- ([PR#4171](https://github.com/dubzzz/fast-check/pull/4171)) CI: Update Devcontainer settings
+- ([PR#4181](https://github.com/dubzzz/fast-check/pull/4181)) CI: Add exempted labels for stale bot
+- ([PR#4136](https://github.com/dubzzz/fast-check/pull/4136)) Clean: Drop dependency @testing-library/jest-dom
+- ([PR#4107](https://github.com/dubzzz/fast-check/pull/4107)) Doc: What's new article for fast-check 3.12.0
+- ([PR#4118](https://github.com/dubzzz/fast-check/pull/4118)) Doc: Drop raw bench results from release note
+- ([PR#4117](https://github.com/dubzzz/fast-check/pull/4117)) Test: Stabilize test related to NaN in exclusive mode
+- ([PR#4033](https://github.com/dubzzz/fast-check/pull/4033)) Tooling: Update formatting
+
+# 3.12.0
+
+_Faster `float`, `double` and `ulid` and excluded min/max_
+[[Code](https://github.com/dubzzz/fast-check/tree/v3.12.0)][[Diff](https://github.com/dubzzz/fast-check/compare/v3.11.0...v3.12.0)]
+
+## Features
+
+- ([PR#4100](https://github.com/dubzzz/fast-check/pull/4100)) Support excluded min/max in `double`
+- ([PR#4105](https://github.com/dubzzz/fast-check/pull/4105)) Support excluded min/max in `float`
+
+## Fixes
+
+- ([PR#4094](https://github.com/dubzzz/fast-check/pull/4094)) Bug: Stop unwrapping `ulid` we cannot build
+- ([PR#4095](https://github.com/dubzzz/fast-check/pull/4095)) Bug: Be resilient to poisoning with `ulid`
+- ([PR#4041](https://github.com/dubzzz/fast-check/pull/4041)) CI: Ensure we use latest node in range
+- ([PR#4062](https://github.com/dubzzz/fast-check/pull/4062)) CI: Update devcontainer configuration
+- ([PR#4065](https://github.com/dubzzz/fast-check/pull/4065)) CI: Better configuration for renovate
+- ([PR#4068](https://github.com/dubzzz/fast-check/pull/4068)) CI: Refine configuration of renovate
+- ([PR#4073](https://github.com/dubzzz/fast-check/pull/4073)) CI: New attempt to configure renovate
+- ([PR#4075](https://github.com/dubzzz/fast-check/pull/4075)) CI: Configure renovate to bump non-package
+- ([PR#4078](https://github.com/dubzzz/fast-check/pull/4078)) CI: Disable nodenv bumps on renovate
+- ([PR#4080](https://github.com/dubzzz/fast-check/pull/4080)) CI: Stop bumping node via renovate
+- ([PR#4040](https://github.com/dubzzz/fast-check/pull/4040)) Doc: Prepare release note for 3.11.0
+- ([PR#4087](https://github.com/dubzzz/fast-check/pull/4087)) Doc: Add new contributor zbjornson
+- ([PR#4059](https://github.com/dubzzz/fast-check/pull/4059)) Performance: Faster `decomposeFloat/Double`
+- ([PR#4088](https://github.com/dubzzz/fast-check/pull/4088)) Performance: Drop some unneeded allocs in `ulid`
+- ([PR#4091](https://github.com/dubzzz/fast-check/pull/4091)) Performance: Faster unmap for `ulid`
+- ([PR#4092](https://github.com/dubzzz/fast-check/pull/4092)) Performance: Faster generation of `ulid`
+- ([PR#4098](https://github.com/dubzzz/fast-check/pull/4098)) Performance: Faster `ulid` mapper function
+- ([PR#4039](https://github.com/dubzzz/fast-check/pull/4039)) Script: Add support for more gitmojis
+
+---
+
+# 3.11.0
+
+_New arbitrary for ulid_
+[[Code](https://github.com/dubzzz/fast-check/tree/v3.11.0)][[Diff](https://github.com/dubzzz/fast-check/compare/v3.10.0...v3.11.0)]
+
+## Features
+
+- ([PR#4020](https://github.com/dubzzz/fast-check/pull/4020)) Implement arbitrary for ulid
+
+## Fixes
+
+- ([PR#3956](https://github.com/dubzzz/fast-check/pull/3956)) CI: Define code owners
+- ([PR#3961](https://github.com/dubzzz/fast-check/pull/3961)) CI: Fix configuration of CodeQL
+- ([PR#3973](https://github.com/dubzzz/fast-check/pull/3973)) CI: Make changelog workflow able to push
+- ([PR#3975](https://github.com/dubzzz/fast-check/pull/3975)) CI: Add scorecard security workflow
+- ([PR#3991](https://github.com/dubzzz/fast-check/pull/3991)) CI: Properly reference tags in GH Actions
+- ([PR#3993](https://github.com/dubzzz/fast-check/pull/3993)) CI: Configure renovate for security bumps
+- ([PR#3994](https://github.com/dubzzz/fast-check/pull/3994)) CI: Stop ignoring examples in renovate
+- ([PR#3995](https://github.com/dubzzz/fast-check/pull/3995)) CI: Enable some more Scorecard's checks
+- ([PR#4007](https://github.com/dubzzz/fast-check/pull/4007)) CI: Fix CI tests for types against next
+- ([PR#4008](https://github.com/dubzzz/fast-check/pull/4008)) CI: Show vulnerabilities in renovate
+- ([PR#3976](https://github.com/dubzzz/fast-check/pull/3976)) Doc: Add some OpenSSF badges
+- ([PR#4034](https://github.com/dubzzz/fast-check/pull/4034)) Doc: Add new contributor vecerek
+- ([PR#4010](https://github.com/dubzzz/fast-check/pull/4010)) Security: Move dockerfile content to devcontainer
+- ([PR#4000](https://github.com/dubzzz/fast-check/pull/4000)) Security: Drop raw install of npm
+- ([PR#3987](https://github.com/dubzzz/fast-check/pull/3987)) Security: Pin npm version for publish
+- ([PR#3985](https://github.com/dubzzz/fast-check/pull/3985)) Security: Pin image in Dockerfile of devcontainer
+- ([PR#3983](https://github.com/dubzzz/fast-check/pull/3983)) Security: Safer workflows' permissions
+- ([PR#3957](https://github.com/dubzzz/fast-check/pull/3957)) Security: Lock GH-Actions dependencies
+
+---
+
+# 3.10.0
+
+_New arbitrary generating strings matching the provided regex: `stringMatching`_
+[[Code](https://github.com/dubzzz/fast-check/tree/v3.10.0)][[Diff](https://github.com/dubzzz/fast-check/compare/v3.9.0...v3.10.0)]
+
+## Features
+
+- ([PR#3920](https://github.com/dubzzz/fast-check/pull/3920)) Prepare tokenizers for `stringMatching`
+- ([PR#3921](https://github.com/dubzzz/fast-check/pull/3921)) Introduce `stringMatching`
+- ([PR#3924](https://github.com/dubzzz/fast-check/pull/3924)) Add support for negate regex
+- ([PR#3925](https://github.com/dubzzz/fast-check/pull/3925)) Explicit ban of unsupported regex flags in `stringMatching`
+- ([PR#3926](https://github.com/dubzzz/fast-check/pull/3926)) Add support for capturing regexes
+- ([PR#3927](https://github.com/dubzzz/fast-check/pull/3927)) Add support for disjunctions in regexes
+- ([PR#3928](https://github.com/dubzzz/fast-check/pull/3928)) Correctly parse ^ and $ in regex
+- ([PR#3929](https://github.com/dubzzz/fast-check/pull/3929)) Correctly parse numeric backreference
+- ([PR#3930](https://github.com/dubzzz/fast-check/pull/3930)) Correctly parse look{ahead,behind} in regexes
+- ([PR#3932](https://github.com/dubzzz/fast-check/pull/3932)) Support empty disjunctions in regexes
+- ([PR#3933](https://github.com/dubzzz/fast-check/pull/3933)) Add parsing support for \p and \k
+- ([PR#3935](https://github.com/dubzzz/fast-check/pull/3935)) Support generation of strings not constrained by ^ or $
+- ([PR#3938](https://github.com/dubzzz/fast-check/pull/3938)) Support regex flags: d, m and s
+- ([PR#3939](https://github.com/dubzzz/fast-check/pull/3939)) Support unicode regexes
+
+## Fixes
+
+- ([PR#3909](https://github.com/dubzzz/fast-check/pull/3909)) Clean: Drop bundle centric tests
+- ([PR#3902](https://github.com/dubzzz/fast-check/pull/3902)) Doc: Release note page for 3.9.0
+- ([PR#3904](https://github.com/dubzzz/fast-check/pull/3904)) Doc: Fix typo in What's new 3.9.0
+- ([PR#3910](https://github.com/dubzzz/fast-check/pull/3910)) Doc: Lazy load image of sponsors
+- ([PR#3911](https://github.com/dubzzz/fast-check/pull/3911)) Doc: Add alt labels on feature badges
+- ([PR#3912](https://github.com/dubzzz/fast-check/pull/3912)) Doc: Stop lazy images in critical viewport
+- ([PR#3913](https://github.com/dubzzz/fast-check/pull/3913)) Doc: Better a11y on feature badges
+- ([PR#3898](https://github.com/dubzzz/fast-check/pull/3898)) Script: Run publint in strict mode
+- ([PR#3903](https://github.com/dubzzz/fast-check/pull/3903)) Test: Rework race conditions specs in tutorial
+- ([PR#3931](https://github.com/dubzzz/fast-check/pull/3931)) Test: Add some more checks on `stringMatching`
+- ([PR#3936](https://github.com/dubzzz/fast-check/pull/3936)) Test: Test against more regexes in `stringMatching`
+- ([PR#3940](https://github.com/dubzzz/fast-check/pull/3940)) Test: Add some more known regexes in our test suite
+
+---
+
+# 3.9.0
+
+_Finer definition of `act` to detect race conditions_
+[[Code](https://github.com/dubzzz/fast-check/tree/v3.9.0)][[Diff](https://github.com/dubzzz/fast-check/compare/v3.8.3...v3.9.0)]
+
+## Features
+
+- ([PR#3889](https://github.com/dubzzz/fast-check/pull/3889)) Add ability to customize `act` per call
+- ([PR#3890](https://github.com/dubzzz/fast-check/pull/3890)) Add ability to customize `act` per wait
+
+## Fixes
+
+- ([PR#3892](https://github.com/dubzzz/fast-check/pull/3892)) Bug: Cap timeout values to 0x7fff_ffff
+
+---
+
+# 3.8.3
+
+_Ensure scheduled models can wait everything needed_
+[[Code](https://github.com/dubzzz/fast-check/tree/v3.8.3)][[Diff](https://github.com/dubzzz/fast-check/compare/v3.8.2...v3.8.3)]
+
+## Fixes
+
+- ([PR#3887](https://github.com/dubzzz/fast-check/pull/3887)) Bug: Always schedule models until the end
+- ([PR#3880](https://github.com/dubzzz/fast-check/pull/3880)) CI: Stabilize tests on `jsonValue`
+- ([PR#3876](https://github.com/dubzzz/fast-check/pull/3876)) Clean: Drop legacy documentation
+- ([PR#3875](https://github.com/dubzzz/fast-check/pull/3875)) Doc: First blog post on docusaurus switch
+
+# 3.8.2
+
+_Rework documentation_
+[[Code](https://github.com/dubzzz/fast-check/tree/v3.8.2)][[Diff](https://github.com/dubzzz/fast-check/compare/v3.8.1...v3.8.2)]
+
+## Fixes
+
+- ([PR#3780](https://github.com/dubzzz/fast-check/pull/3780)) CI: Do not relaunch build on new tag
+- ([PR#3792](https://github.com/dubzzz/fast-check/pull/3792)) CI: Remove parse5 when checking types
+- ([PR#3804](https://github.com/dubzzz/fast-check/pull/3804)) CI: Build documentation with LFS enabled
+- ([PR#3800](https://github.com/dubzzz/fast-check/pull/3800)) Doc: Add "advanced" part of the documentation
+- ([PR#3803](https://github.com/dubzzz/fast-check/pull/3803)) Doc: Update our-first-property-based-test.md: typo, punctuation
+- ([PR#3828](https://github.com/dubzzz/fast-check/pull/3828)) Doc: Fix typos in docs
+- ([PR#3820](https://github.com/dubzzz/fast-check/pull/3820)) Doc: First iteration on race conditions tutorial
+- ([PR#3834](https://github.com/dubzzz/fast-check/pull/3834)) Doc: Rework intro of race condition tutorial
+- ([PR#3836](https://github.com/dubzzz/fast-check/pull/3836)) Doc: Merge category and intro for race condition
+- ([PR#3837](https://github.com/dubzzz/fast-check/pull/3837)) Doc: Replace categories by real pages
+- ([PR#3838](https://github.com/dubzzz/fast-check/pull/3838)) Doc: Add video explaining race condition in UI
+- ([PR#3842](https://github.com/dubzzz/fast-check/pull/3842)) Doc: Note about solving race conditions
+- ([PR#3843](https://github.com/dubzzz/fast-check/pull/3843)) Doc: Better colors for dark theme
+- ([PR#3850](https://github.com/dubzzz/fast-check/pull/3850)) Doc: Points to projects in our ecosystem
+- ([PR#3852](https://github.com/dubzzz/fast-check/pull/3852)) Doc: List some bugs found thanks to fast-check
+- ([PR#3860](https://github.com/dubzzz/fast-check/pull/3860)) Doc: Use GitHub logo instead of label
+- ([PR#3858](https://github.com/dubzzz/fast-check/pull/3858)) Doc: Rework homepage page of fast-check.dev
+- ([PR#3863](https://github.com/dubzzz/fast-check/pull/3863)) Doc: Rework display of the homepage for small screens
+- ([PR#3864](https://github.com/dubzzz/fast-check/pull/3864)) Doc: Properly display the quick nav buttons
+- ([PR#3871](https://github.com/dubzzz/fast-check/pull/3871)) Doc: Update all links to new documentation
+- ([PR#3867](https://github.com/dubzzz/fast-check/pull/3867)) Doc: Create proper images in website/
+- ([PR#3872](https://github.com/dubzzz/fast-check/pull/3872)) Doc: Reference image from LFS in README
+- ([PR#3835](https://github.com/dubzzz/fast-check/pull/3835)) Test: Add tests for snippets in the website
+
+# 3.8.1
+
+_New website for the documentation_
+[[Code](https://github.com/dubzzz/fast-check/tree/v3.8.1)][[Diff](https://github.com/dubzzz/fast-check/compare/v3.8.0...v3.8.1)]
+
+## Fixes
+
+- ([PR#3723](https://github.com/dubzzz/fast-check/pull/3723)) CI: Switch to docusaurus for the documentation
+- ([PR#3729](https://github.com/dubzzz/fast-check/pull/3729)) CI: Pre-setup devcontainer with GH Actions
+- ([PR#3728](https://github.com/dubzzz/fast-check/pull/3728)) CI: Change gh-pages deploy process
+- ([PR#3732](https://github.com/dubzzz/fast-check/pull/3732)) CI: Move back to github-pages-deploy-action
+- ([PR#3735](https://github.com/dubzzz/fast-check/pull/3735)) CI: Add gtag for analytics
+- ([PR#3744](https://github.com/dubzzz/fast-check/pull/3744)) CI: Drop website build on `build:all`
+- ([PR#3751](https://github.com/dubzzz/fast-check/pull/3751)) CI: Update `baseUrl` on the ain documentation
+- ([PR#3754](https://github.com/dubzzz/fast-check/pull/3754)) CI: Drop version from website
+- ([PR#3754](https://github.com/dubzzz/fast-check/pull/3754)) CI: Drop version from website
+- ([PR#3759](https://github.com/dubzzz/fast-check/pull/3759)) CI: Drop the need for a branch on doc
+- ([PR#3775](https://github.com/dubzzz/fast-check/pull/3775)) CI: Publish all packages in one workflow
+- ([PR#3724](https://github.com/dubzzz/fast-check/pull/3724)) Doc: Add fuzz keywords
+- ([PR#3734](https://github.com/dubzzz/fast-check/pull/3734)) Doc: Add search capability to the doc
+- ([PR#3738](https://github.com/dubzzz/fast-check/pull/3738)) Doc: Fix broken links to api-reference
+- ([PR#3745](https://github.com/dubzzz/fast-check/pull/3745)) Doc: Document core building blocks in new documentation
+- ([PR#3750](https://github.com/dubzzz/fast-check/pull/3750)) Doc: More details into tips/larger-entries...
+- ([PR#3753](https://github.com/dubzzz/fast-check/pull/3753)) Doc: Add some more configuration tips in the documentation
+- ([PR#3755](https://github.com/dubzzz/fast-check/pull/3755)) Doc: Update all links to target fast-check.dev
+- ([PR#3757](https://github.com/dubzzz/fast-check/pull/3757)) Doc: Quick a11y pass on the documentation
+- ([PR#3758](https://github.com/dubzzz/fast-check/pull/3758)) Doc: Move missing configuration parts to new doc
+- ([PR#3760](https://github.com/dubzzz/fast-check/pull/3760)) Doc: Link directly to the target page not to 30x ones
+- ([PR#3761](https://github.com/dubzzz/fast-check/pull/3761)) Doc: Fix broken links in new doc
+- ([PR#3774](https://github.com/dubzzz/fast-check/pull/3774)) Security: Attach provenance to the packages
+- ([PR#3719](https://github.com/dubzzz/fast-check/pull/3719)) Script: Ensure proper package definition
+
+# 3.8.0
+
+_Introduce new `gen` arbitrary_
+[[Code](https://github.com/dubzzz/fast-check/tree/v3.8.0)][[Diff](https://github.com/dubzzz/fast-check/compare/v3.7.1...v3.8.0)]
+
+## Features
+
+- ([PR#3395](https://github.com/dubzzz/fast-check/pull/3395)) Introduce new `gen` arbitrary
+
+## Fixes
+
+- ([PR#3706](https://github.com/dubzzz/fast-check/pull/3706)) Doc: Document newly added `fc.gen()`
+
+---
+
+# 3.7.1
+
+_Safer declaration of types in package.json_
+[[Code](https://github.com/dubzzz/fast-check/tree/v3.7.1)][[Diff](https://github.com/dubzzz/fast-check/compare/v3.7.0...v3.7.1)]
+
+## Fixes
+
+- ([PR#3671](https://github.com/dubzzz/fast-check/pull/3671)) Bug: Declare types field first in exports
+- ([PR#3646](https://github.com/dubzzz/fast-check/pull/3646)) Doc: Fix a typo in Runners.md
+
+# 3.7.0
+
+_Better error reports without duplicated messages_
+[[Code](https://github.com/dubzzz/fast-check/tree/v3.7.0)][[Diff](https://github.com/dubzzz/fast-check/compare/v3.6.3...v3.7.0)]
+
+## Features
+
+- ([PR#3638](https://github.com/dubzzz/fast-check/pull/3638)) Stop repeating the error twice in reports
+
+## Fixes
+
+- ([PR#3637](https://github.com/dubzzz/fast-check/pull/3637)) CI: Update ts-jest configuration files
+
+---
+
+# 3.6.3
+
+_Fix broken replay based on path_
+[[Code](https://github.com/dubzzz/fast-check/tree/v3.6.3)][[Diff](https://github.com/dubzzz/fast-check/compare/v3.6.2...v3.6.3)]
+
+## Fixes
+
+- ([PR#3617](https://github.com/dubzzz/fast-check/pull/3617)) Bug: Fix broken replay based on path
+- ([PR#3583](https://github.com/dubzzz/fast-check/pull/3583)) CI: Do not run publish workflow of fast-check for vitest
+- ([PR#3616](https://github.com/dubzzz/fast-check/pull/3616)) CI: Always build against latest node
+
+# 3.6.2
+
+_Still work in fake timer contexts_
+[[Code](https://github.com/dubzzz/fast-check/tree/v3.6.2)][[Diff](https://github.com/dubzzz/fast-check/compare/v3.6.1...v3.6.2)]
+
+## Fixes
+
+- ([PR#3571](https://github.com/dubzzz/fast-check/pull/3571)) Bug: Resist to fake timers in interruptAfterTimeLimit
+- ([PR#3572](https://github.com/dubzzz/fast-check/pull/3572)) Bug: Resist to fake timers in timeout
+- ([PR#3564](https://github.com/dubzzz/fast-check/pull/3564)) Performance: Drop bailout linked to toss
+
+# 3.6.1
+
+_Some more performance improvements_
+[[Code](https://github.com/dubzzz/fast-check/tree/v3.6.1)][[Diff](https://github.com/dubzzz/fast-check/compare/v3.6.0...v3.6.1)]
+
+## Fixes
+
+- ([PR#3563](https://github.com/dubzzz/fast-check/pull/3563)) Performance: Mutate rng inplace in tosser
+
+# 3.6.0
+
+_Slightly faster execution of properties_
+[[Code](https://github.com/dubzzz/fast-check/tree/v3.6.0)][[Diff](https://github.com/dubzzz/fast-check/compare/v3.5.0...v3.6.0)]
+
+## Features
+
+- ([PR#3547](https://github.com/dubzzz/fast-check/pull/3547)) Slightly faster thanks to pure-rand v6
+- ([PR#3552](https://github.com/dubzzz/fast-check/pull/3552)) Do not wrap stream when dropping 0 items
+- ([PR#3551](https://github.com/dubzzz/fast-check/pull/3551)) Faster implementation of internal function `runIdToFrequency`
+- ([PR#3553](https://github.com/dubzzz/fast-check/pull/3553)) Drop useless internal stream conversions
+- ([PR#3554](https://github.com/dubzzz/fast-check/pull/3554)) Tosser must immediately produce values
+
+## Fixes
+
+- ([PR#3556](https://github.com/dubzzz/fast-check/pull/3556)) CI: Enable sourceMap in unpublished for coverage
+- ([PR#3512](https://github.com/dubzzz/fast-check/pull/3512)) Script: Add `--cache` option to Prettier
+- ([PR#3523](https://github.com/dubzzz/fast-check/pull/3523)) Script: Initialize default devcontainer
+- ([PR#3524](https://github.com/dubzzz/fast-check/pull/3524)) Script: Install and setup nvs inside Dockerfile
+
+---
+
+# 3.5.1
+
+_Still work in fake timer contexts_
+[[Code](https://github.com/dubzzz/fast-check/tree/v3.5.1)][[Diff](https://github.com/dubzzz/fast-check/compare/v3.5.0...v3.5.1)]
+
+## Fixes
+
+- ([PR#3571](https://github.com/dubzzz/fast-check/pull/3571)) Bug: Resist to fake timers in interruptAfterTimeLimit
+- ([PR#3572](https://github.com/dubzzz/fast-check/pull/3572)) Bug: Resist to fake timers in timeout
+
+# 3.5.0
+
+_Interrupt running tasks when `interruptAfterTimeLimit` exceeded_
+[[Code](https://github.com/dubzzz/fast-check/tree/v3.5.0)][[Diff](https://github.com/dubzzz/fast-check/compare/v3.4.0...v3.5.0)]
+
+## Features
+
+- ([PR#3507](https://github.com/dubzzz/fast-check/pull/3507)) Interrupt predicates when `interruptAfterTimeLimit`
+- ([PR#3508](https://github.com/dubzzz/fast-check/pull/3508)) Mark interrupted runs without any success as failures
+
+---
+
+# 3.4.0
+
+_Better handling of timeout with beforeEach and afterEach_
+[[Code](https://github.com/dubzzz/fast-check/tree/v3.4.0)][[Diff](https://github.com/dubzzz/fast-check/compare/v3.3.0...v3.4.0)]
+
+## Features
+
+- ([PR#3464](https://github.com/dubzzz/fast-check/pull/3464)) No timeout for beforeEach or afterEach
+
+## Fixes
+
+- ([PR#3428](https://github.com/dubzzz/fast-check/pull/3428)) Bug: Avoid stack overflow during shrinking of tuples
+- ([PR#3432](https://github.com/dubzzz/fast-check/pull/3432)) Bug: Avoid stack overflow during shrinking of arrays
+- ([PR#3354](https://github.com/dubzzz/fast-check/pull/3354)) CI: Ignore version bump checks on publish
+- ([PR#3379](https://github.com/dubzzz/fast-check/pull/3379)) CI: Fix configuration for rollup esm tests
+- ([PR#3394](https://github.com/dubzzz/fast-check/pull/3394)) CI: Limit scope of "All ...bump declared"
+- ([PR#3393](https://github.com/dubzzz/fast-check/pull/3393)) CI: Run tests against Node 18.x
+- ([PR#3446](https://github.com/dubzzz/fast-check/pull/3446)) CI: Drop circular deps for dev topo builds
+- ([PR#3417](https://github.com/dubzzz/fast-check/pull/3417)) Clean: Drop v2 to v3 codemods from the repository
+- ([PR#3351](https://github.com/dubzzz/fast-check/pull/3351)) Doc: Update changelogs following backports
+- ([PR#3458](https://github.com/dubzzz/fast-check/pull/3458)) Doc: Document how to use `context` in `examples`
+- ([PR#3476](https://github.com/dubzzz/fast-check/pull/3476)) Doc: Revamp sponsoring section to show GitHub Sponsors
+- ([PR#3473](https://github.com/dubzzz/fast-check/pull/3473)) Funding: Re-order links in funding section
+- ([PR#3427](https://github.com/dubzzz/fast-check/pull/3427)) Refactor: Expose shrinker of tuples internally
+- ([PR#3468](https://github.com/dubzzz/fast-check/pull/3468)) Script: Ensure we don't release workspace-based packages
+
+---
+
+# 3.3.0
+
+_Expose `webPath` arbitrary_
+[[Code](https://github.com/dubzzz/fast-check/tree/v3.3.0)][[Diff](https://github.com/dubzzz/fast-check/compare/v3.2.0...v3.3.0)]
+
+## Features
+
+- ([PR#3299](https://github.com/dubzzz/fast-check/pull/3299)) Explicitly declare typings for constraints on `date`
+- ([PR#3300](https://github.com/dubzzz/fast-check/pull/3300)) Expose an url path builder called `webPath`
+
+## Fixes
+
+- ([PR#3328](https://github.com/dubzzz/fast-check/pull/3328)) CI: Drop netlify related code and "please
+ 
+
+
++Property based testing framework for JavaScript/TypeScript +
+ +
+ 
+ 
+ 
+
+ 
+ 
+ 
+
+
+
+ 
+ 
+
+
+
+### ReScript bindings
+
+Bindings to use fast-check in [ReScript](https://rescript-lang.org) are available in package [rescript-fast-check](https://www.npmjs.com/rescript-fast-check). They are maintained by [@TheSpyder](https://github.com/TheSpyder) as an external project.
+
+## Contributors ✨
+
+Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):
+
+
+
+
+More details...
+ +1. Except for features that cannot be polyfilled - such as `bigint`-related ones - all the capabilities of fast-check should be usable given you use at least the minimal recommended version of node associated to your major of fast-check. +2. Require either lib or target ≥ ES2020 or `@types/node` to be installed. +3. Require either lib or target ≥ ES2015 or `@types/node` to be installed. + +
+
+You can also become one of them by contributing via [GitHub Sponsors](https://github.com/sponsors/dubzzz) or [OpenCollective](https://opencollective.com/fast-check/contribute).
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/AdapterArbitrary.js b/node_modules/fast-check/lib/arbitrary/_internals/AdapterArbitrary.js
new file mode 100644
index 0000000000000000000000000000000000000000..3ec4625f986e19d7c208701217c882bd3906e59b
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/AdapterArbitrary.js
@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adapter = adapter;
+const Arbitrary_1 = require("../../check/arbitrary/definition/Arbitrary");
+const Value_1 = require("../../check/arbitrary/definition/Value");
+const Stream_1 = require("../../stream/Stream");
+const AdaptedValue = Symbol('adapted-value');
+function toAdapterValue(rawValue, adapter) {
+ const adapted = adapter(rawValue.value_);
+ if (!adapted.adapted) {
+ return rawValue;
+ }
+ return new Value_1.Value(adapted.value, AdaptedValue);
+}
+class AdapterArbitrary extends Arbitrary_1.Arbitrary {
+ constructor(sourceArb, adapter) {
+ super();
+ this.sourceArb = sourceArb;
+ this.adapter = adapter;
+ this.adaptValue = (rawValue) => toAdapterValue(rawValue, adapter);
+ }
+ generate(mrng, biasFactor) {
+ const rawValue = this.sourceArb.generate(mrng, biasFactor);
+ return this.adaptValue(rawValue);
+ }
+ canShrinkWithoutContext(value) {
+ return this.sourceArb.canShrinkWithoutContext(value) && !this.adapter(value).adapted;
+ }
+ shrink(value, context) {
+ if (context === AdaptedValue) {
+ if (!this.sourceArb.canShrinkWithoutContext(value)) {
+ return Stream_1.Stream.nil();
+ }
+ return this.sourceArb.shrink(value, undefined).map(this.adaptValue);
+ }
+ return this.sourceArb.shrink(value, context).map(this.adaptValue);
+ }
+}
+function adapter(sourceArb, adapter) {
+ return new AdapterArbitrary(sourceArb, adapter);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/AlwaysShrinkableArbitrary.js b/node_modules/fast-check/lib/arbitrary/_internals/AlwaysShrinkableArbitrary.js
new file mode 100644
index 0000000000000000000000000000000000000000..567746da32a2060fff2ef2e63af2ec46580a4b5b
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/AlwaysShrinkableArbitrary.js
@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlwaysShrinkableArbitrary = void 0;
+const Arbitrary_1 = require("../../check/arbitrary/definition/Arbitrary");
+const Stream_1 = require("../../stream/Stream");
+const NoUndefinedAsContext_1 = require("./helpers/NoUndefinedAsContext");
+class AlwaysShrinkableArbitrary extends Arbitrary_1.Arbitrary {
+ constructor(arb) {
+ super();
+ this.arb = arb;
+ }
+ generate(mrng, biasFactor) {
+ const value = this.arb.generate(mrng, biasFactor);
+ return (0, NoUndefinedAsContext_1.noUndefinedAsContext)(value);
+ }
+ canShrinkWithoutContext(value) {
+ return true;
+ }
+ shrink(value, context) {
+ if (context === undefined && !this.arb.canShrinkWithoutContext(value)) {
+ return Stream_1.Stream.nil();
+ }
+ const safeContext = context !== NoUndefinedAsContext_1.UndefinedContextPlaceholder ? context : undefined;
+ return this.arb.shrink(value, safeContext).map(NoUndefinedAsContext_1.noUndefinedAsContext);
+ }
+}
+exports.AlwaysShrinkableArbitrary = AlwaysShrinkableArbitrary;
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/ArrayArbitrary.js b/node_modules/fast-check/lib/arbitrary/_internals/ArrayArbitrary.js
new file mode 100644
index 0000000000000000000000000000000000000000..f268b14beebf180fb125d622a66db626ee691b61
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/ArrayArbitrary.js
@@ -0,0 +1,223 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayArbitrary = void 0;
+const Stream_1 = require("../../stream/Stream");
+const symbols_1 = require("../../check/symbols");
+const integer_1 = require("../integer");
+const LazyIterableIterator_1 = require("../../stream/LazyIterableIterator");
+const Arbitrary_1 = require("../../check/arbitrary/definition/Arbitrary");
+const Value_1 = require("../../check/arbitrary/definition/Value");
+const DepthContext_1 = require("./helpers/DepthContext");
+const BuildSlicedGenerator_1 = require("./helpers/BuildSlicedGenerator");
+const globals_1 = require("../../utils/globals");
+const safeMathFloor = Math.floor;
+const safeMathLog = Math.log;
+const safeMathMax = Math.max;
+const safeArrayIsArray = Array.isArray;
+function biasedMaxLength(minLength, maxLength) {
+ if (minLength === maxLength) {
+ return minLength;
+ }
+ return minLength + safeMathFloor(safeMathLog(maxLength - minLength) / safeMathLog(2));
+}
+class ArrayArbitrary extends Arbitrary_1.Arbitrary {
+ constructor(arb, minLength, maxGeneratedLength, maxLength, depthIdentifier, setBuilder, customSlices) {
+ super();
+ this.arb = arb;
+ this.minLength = minLength;
+ this.maxGeneratedLength = maxGeneratedLength;
+ this.maxLength = maxLength;
+ this.setBuilder = setBuilder;
+ this.customSlices = customSlices;
+ this.lengthArb = (0, integer_1.integer)({ min: minLength, max: maxGeneratedLength });
+ this.depthContext = (0, DepthContext_1.getDepthContextFor)(depthIdentifier);
+ }
+ preFilter(tab) {
+ if (this.setBuilder === undefined) {
+ return tab;
+ }
+ const s = this.setBuilder();
+ for (let index = 0; index !== tab.length; ++index) {
+ s.tryAdd(tab[index]);
+ }
+ return s.getData();
+ }
+ static makeItCloneable(vs, shrinkables) {
+ vs[symbols_1.cloneMethod] = () => {
+ const cloned = [];
+ for (let idx = 0; idx !== shrinkables.length; ++idx) {
+ (0, globals_1.safePush)(cloned, shrinkables[idx].value);
+ }
+ this.makeItCloneable(cloned, shrinkables);
+ return cloned;
+ };
+ return vs;
+ }
+ generateNItemsNoDuplicates(setBuilder, N, mrng, biasFactorItems) {
+ let numSkippedInRow = 0;
+ const s = setBuilder();
+ const slicedGenerator = (0, BuildSlicedGenerator_1.buildSlicedGenerator)(this.arb, mrng, this.customSlices, biasFactorItems);
+ while (s.size() < N && numSkippedInRow < this.maxGeneratedLength) {
+ const current = slicedGenerator.next();
+ if (s.tryAdd(current)) {
+ numSkippedInRow = 0;
+ }
+ else {
+ numSkippedInRow += 1;
+ }
+ }
+ return s.getData();
+ }
+ safeGenerateNItemsNoDuplicates(setBuilder, N, mrng, biasFactorItems) {
+ const depthImpact = safeMathMax(0, N - biasedMaxLength(this.minLength, this.maxGeneratedLength));
+ this.depthContext.depth += depthImpact;
+ try {
+ return this.generateNItemsNoDuplicates(setBuilder, N, mrng, biasFactorItems);
+ }
+ finally {
+ this.depthContext.depth -= depthImpact;
+ }
+ }
+ generateNItems(N, mrng, biasFactorItems) {
+ const items = [];
+ const slicedGenerator = (0, BuildSlicedGenerator_1.buildSlicedGenerator)(this.arb, mrng, this.customSlices, biasFactorItems);
+ slicedGenerator.attemptExact(N);
+ for (let index = 0; index !== N; ++index) {
+ const current = slicedGenerator.next();
+ (0, globals_1.safePush)(items, current);
+ }
+ return items;
+ }
+ safeGenerateNItems(N, mrng, biasFactorItems) {
+ const depthImpact = safeMathMax(0, N - biasedMaxLength(this.minLength, this.maxGeneratedLength));
+ this.depthContext.depth += depthImpact;
+ try {
+ return this.generateNItems(N, mrng, biasFactorItems);
+ }
+ finally {
+ this.depthContext.depth -= depthImpact;
+ }
+ }
+ wrapper(itemsRaw, shrunkOnce, itemsRawLengthContext, startIndex) {
+ const items = shrunkOnce ? this.preFilter(itemsRaw) : itemsRaw;
+ let cloneable = false;
+ const vs = [];
+ const itemsContexts = [];
+ for (let idx = 0; idx !== items.length; ++idx) {
+ const s = items[idx];
+ cloneable = cloneable || s.hasToBeCloned;
+ (0, globals_1.safePush)(vs, s.value);
+ (0, globals_1.safePush)(itemsContexts, s.context);
+ }
+ if (cloneable) {
+ ArrayArbitrary.makeItCloneable(vs, items);
+ }
+ const context = {
+ shrunkOnce,
+ lengthContext: itemsRaw.length === items.length && itemsRawLengthContext !== undefined
+ ? itemsRawLengthContext
+ : undefined,
+ itemsContexts,
+ startIndex,
+ };
+ return new Value_1.Value(vs, context);
+ }
+ generate(mrng, biasFactor) {
+ const biasMeta = this.applyBias(mrng, biasFactor);
+ const targetSize = biasMeta.size;
+ const items = this.setBuilder !== undefined
+ ? this.safeGenerateNItemsNoDuplicates(this.setBuilder, targetSize, mrng, biasMeta.biasFactorItems)
+ : this.safeGenerateNItems(targetSize, mrng, biasMeta.biasFactorItems);
+ return this.wrapper(items, false, undefined, 0);
+ }
+ applyBias(mrng, biasFactor) {
+ if (biasFactor === undefined) {
+ return { size: this.lengthArb.generate(mrng, undefined).value };
+ }
+ if (this.minLength === this.maxGeneratedLength) {
+ return { size: this.lengthArb.generate(mrng, undefined).value, biasFactorItems: biasFactor };
+ }
+ if (mrng.nextInt(1, biasFactor) !== 1) {
+ return { size: this.lengthArb.generate(mrng, undefined).value };
+ }
+ if (mrng.nextInt(1, biasFactor) !== 1 || this.minLength === this.maxGeneratedLength) {
+ return { size: this.lengthArb.generate(mrng, undefined).value, biasFactorItems: biasFactor };
+ }
+ const maxBiasedLength = biasedMaxLength(this.minLength, this.maxGeneratedLength);
+ const targetSizeValue = (0, integer_1.integer)({ min: this.minLength, max: maxBiasedLength }).generate(mrng, undefined);
+ return { size: targetSizeValue.value, biasFactorItems: biasFactor };
+ }
+ canShrinkWithoutContext(value) {
+ if (!safeArrayIsArray(value) || this.minLength > value.length || value.length > this.maxLength) {
+ return false;
+ }
+ for (let index = 0; index !== value.length; ++index) {
+ if (!(index in value)) {
+ return false;
+ }
+ if (!this.arb.canShrinkWithoutContext(value[index])) {
+ return false;
+ }
+ }
+ const filtered = this.preFilter((0, globals_1.safeMap)(value, (item) => new Value_1.Value(item, undefined)));
+ return filtered.length === value.length;
+ }
+ shrinkItemByItem(value, safeContext, endIndex) {
+ const shrinks = [];
+ for (let index = safeContext.startIndex; index < endIndex; ++index) {
+ (0, globals_1.safePush)(shrinks, (0, LazyIterableIterator_1.makeLazy)(() => this.arb.shrink(value[index], safeContext.itemsContexts[index]).map((v) => {
+ const beforeCurrent = (0, globals_1.safeMap)((0, globals_1.safeSlice)(value, 0, index), (v, i) => new Value_1.Value((0, symbols_1.cloneIfNeeded)(v), safeContext.itemsContexts[i]));
+ const afterCurrent = (0, globals_1.safeMap)((0, globals_1.safeSlice)(value, index + 1), (v, i) => new Value_1.Value((0, symbols_1.cloneIfNeeded)(v), safeContext.itemsContexts[i + index + 1]));
+ return [
+ [...beforeCurrent, v, ...afterCurrent],
+ undefined,
+ index,
+ ];
+ })));
+ }
+ return Stream_1.Stream.nil().join(...shrinks);
+ }
+ shrinkImpl(value, context) {
+ if (value.length === 0) {
+ return Stream_1.Stream.nil();
+ }
+ const safeContext = context !== undefined
+ ? context
+ : { shrunkOnce: false, lengthContext: undefined, itemsContexts: [], startIndex: 0 };
+ return (this.lengthArb
+ .shrink(value.length, safeContext.lengthContext)
+ .drop(safeContext.shrunkOnce && safeContext.lengthContext === undefined && value.length > this.minLength + 1
+ ? 1
+ : 0)
+ .map((lengthValue) => {
+ const sliceStart = value.length - lengthValue.value;
+ return [
+ (0, globals_1.safeMap)((0, globals_1.safeSlice)(value, sliceStart), (v, index) => new Value_1.Value((0, symbols_1.cloneIfNeeded)(v), safeContext.itemsContexts[index + sliceStart])),
+ lengthValue.context,
+ 0,
+ ];
+ })
+ .join((0, LazyIterableIterator_1.makeLazy)(() => value.length > this.minLength
+ ? this.shrinkItemByItem(value, safeContext, 1)
+ : this.shrinkItemByItem(value, safeContext, value.length)))
+ .join(value.length > this.minLength
+ ? (0, LazyIterableIterator_1.makeLazy)(() => {
+ const subContext = {
+ shrunkOnce: false,
+ lengthContext: undefined,
+ itemsContexts: (0, globals_1.safeSlice)(safeContext.itemsContexts, 1),
+ startIndex: 0,
+ };
+ return this.shrinkImpl((0, globals_1.safeSlice)(value, 1), subContext)
+ .filter((v) => this.minLength <= v[0].length + 1)
+ .map((v) => {
+ return [[new Value_1.Value((0, symbols_1.cloneIfNeeded)(value[0]), safeContext.itemsContexts[0]), ...v[0]], undefined, 0];
+ });
+ })
+ : Stream_1.Stream.nil()));
+ }
+ shrink(value, context) {
+ return this.shrinkImpl(value, context).map((contextualValue) => this.wrapper(contextualValue[0], true, contextualValue[1], contextualValue[2]));
+ }
+}
+exports.ArrayArbitrary = ArrayArbitrary;
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/ArrayInt64Arbitrary.js b/node_modules/fast-check/lib/arbitrary/_internals/ArrayInt64Arbitrary.js
new file mode 100644
index 0000000000000000000000000000000000000000..dcd81ed2974fd6729ec011c8a1a96bf48aec80a6
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/ArrayInt64Arbitrary.js
@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayInt64 = arrayInt64;
+const Stream_1 = require("../../stream/Stream");
+const Arbitrary_1 = require("../../check/arbitrary/definition/Arbitrary");
+const Value_1 = require("../../check/arbitrary/definition/Value");
+const ArrayInt64_1 = require("./helpers/ArrayInt64");
+class ArrayInt64Arbitrary extends Arbitrary_1.Arbitrary {
+ constructor(min, max) {
+ super();
+ this.min = min;
+ this.max = max;
+ this.biasedRanges = null;
+ }
+ generate(mrng, biasFactor) {
+ const range = this.computeGenerateRange(mrng, biasFactor);
+ const uncheckedValue = mrng.nextArrayInt(range.min, range.max);
+ if (uncheckedValue.data.length === 1) {
+ uncheckedValue.data.unshift(0);
+ }
+ return new Value_1.Value(uncheckedValue, undefined);
+ }
+ computeGenerateRange(mrng, biasFactor) {
+ if (biasFactor === undefined || mrng.nextInt(1, biasFactor) !== 1) {
+ return { min: this.min, max: this.max };
+ }
+ const ranges = this.retrieveBiasedRanges();
+ if (ranges.length === 1) {
+ return ranges[0];
+ }
+ const id = mrng.nextInt(-2 * (ranges.length - 1), ranges.length - 2);
+ return id < 0 ? ranges[0] : ranges[id + 1];
+ }
+ canShrinkWithoutContext(value) {
+ const unsafeValue = value;
+ return (typeof value === 'object' &&
+ value !== null &&
+ (unsafeValue.sign === -1 || unsafeValue.sign === 1) &&
+ Array.isArray(unsafeValue.data) &&
+ unsafeValue.data.length === 2 &&
+ (((0, ArrayInt64_1.isStrictlySmaller64)(this.min, unsafeValue) && (0, ArrayInt64_1.isStrictlySmaller64)(unsafeValue, this.max)) ||
+ (0, ArrayInt64_1.isEqual64)(this.min, unsafeValue) ||
+ (0, ArrayInt64_1.isEqual64)(this.max, unsafeValue)));
+ }
+ shrinkArrayInt64(value, target, tryTargetAsap) {
+ const realGap = (0, ArrayInt64_1.substract64)(value, target);
+ function* shrinkGen() {
+ let previous = tryTargetAsap ? undefined : target;
+ const gap = tryTargetAsap ? realGap : (0, ArrayInt64_1.halve64)(realGap);
+ for (let toremove = gap; !(0, ArrayInt64_1.isZero64)(toremove); toremove = (0, ArrayInt64_1.halve64)(toremove)) {
+ const next = (0, ArrayInt64_1.substract64)(value, toremove);
+ yield new Value_1.Value(next, previous);
+ previous = next;
+ }
+ }
+ return (0, Stream_1.stream)(shrinkGen());
+ }
+ shrink(current, context) {
+ if (!ArrayInt64Arbitrary.isValidContext(current, context)) {
+ const target = this.defaultTarget();
+ return this.shrinkArrayInt64(current, target, true);
+ }
+ if (this.isLastChanceTry(current, context)) {
+ return Stream_1.Stream.of(new Value_1.Value(context, undefined));
+ }
+ return this.shrinkArrayInt64(current, context, false);
+ }
+ defaultTarget() {
+ if (!(0, ArrayInt64_1.isStrictlyPositive64)(this.min) && !(0, ArrayInt64_1.isStrictlyNegative64)(this.max)) {
+ return ArrayInt64_1.Zero64;
+ }
+ return (0, ArrayInt64_1.isStrictlyNegative64)(this.min) ? this.max : this.min;
+ }
+ isLastChanceTry(current, context) {
+ if ((0, ArrayInt64_1.isZero64)(current)) {
+ return false;
+ }
+ if (current.sign === 1) {
+ return (0, ArrayInt64_1.isEqual64)(current, (0, ArrayInt64_1.add64)(context, ArrayInt64_1.Unit64)) && (0, ArrayInt64_1.isStrictlyPositive64)((0, ArrayInt64_1.substract64)(current, this.min));
+ }
+ else {
+ return (0, ArrayInt64_1.isEqual64)(current, (0, ArrayInt64_1.substract64)(context, ArrayInt64_1.Unit64)) && (0, ArrayInt64_1.isStrictlyNegative64)((0, ArrayInt64_1.substract64)(current, this.max));
+ }
+ }
+ static isValidContext(_current, context) {
+ if (context === undefined) {
+ return false;
+ }
+ if (typeof context !== 'object' || context === null || !('sign' in context) || !('data' in context)) {
+ throw new Error(`Invalid context type passed to ArrayInt64Arbitrary (#1)`);
+ }
+ return true;
+ }
+ retrieveBiasedRanges() {
+ if (this.biasedRanges != null) {
+ return this.biasedRanges;
+ }
+ if ((0, ArrayInt64_1.isEqual64)(this.min, this.max)) {
+ this.biasedRanges = [{ min: this.min, max: this.max }];
+ return this.biasedRanges;
+ }
+ const minStrictlySmallerZero = (0, ArrayInt64_1.isStrictlyNegative64)(this.min);
+ const maxStrictlyGreaterZero = (0, ArrayInt64_1.isStrictlyPositive64)(this.max);
+ if (minStrictlySmallerZero && maxStrictlyGreaterZero) {
+ const logMin = (0, ArrayInt64_1.logLike64)(this.min);
+ const logMax = (0, ArrayInt64_1.logLike64)(this.max);
+ this.biasedRanges = [
+ { min: logMin, max: logMax },
+ { min: (0, ArrayInt64_1.substract64)(this.max, logMax), max: this.max },
+ { min: this.min, max: (0, ArrayInt64_1.substract64)(this.min, logMin) },
+ ];
+ }
+ else {
+ const logGap = (0, ArrayInt64_1.logLike64)((0, ArrayInt64_1.substract64)(this.max, this.min));
+ const arbCloseToMin = { min: this.min, max: (0, ArrayInt64_1.add64)(this.min, logGap) };
+ const arbCloseToMax = { min: (0, ArrayInt64_1.substract64)(this.max, logGap), max: this.max };
+ this.biasedRanges = minStrictlySmallerZero
+ ? [arbCloseToMax, arbCloseToMin]
+ : [arbCloseToMin, arbCloseToMax];
+ }
+ return this.biasedRanges;
+ }
+}
+function arrayInt64(min, max) {
+ const arb = new ArrayInt64Arbitrary(min, max);
+ return arb;
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/BigIntArbitrary.js b/node_modules/fast-check/lib/arbitrary/_internals/BigIntArbitrary.js
new file mode 100644
index 0000000000000000000000000000000000000000..b8e05aa5bc5bea3e739f163a5fe4fb27574ba2b4
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/BigIntArbitrary.js
@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BigIntArbitrary = void 0;
+const Stream_1 = require("../../stream/Stream");
+const Arbitrary_1 = require("../../check/arbitrary/definition/Arbitrary");
+const Value_1 = require("../../check/arbitrary/definition/Value");
+const BiasNumericRange_1 = require("./helpers/BiasNumericRange");
+const ShrinkBigInt_1 = require("./helpers/ShrinkBigInt");
+const globals_1 = require("../../utils/globals");
+class BigIntArbitrary extends Arbitrary_1.Arbitrary {
+ constructor(min, max) {
+ super();
+ this.min = min;
+ this.max = max;
+ }
+ generate(mrng, biasFactor) {
+ const range = this.computeGenerateRange(mrng, biasFactor);
+ return new Value_1.Value(mrng.nextBigInt(range.min, range.max), undefined);
+ }
+ computeGenerateRange(mrng, biasFactor) {
+ if (biasFactor === undefined || mrng.nextInt(1, biasFactor) !== 1) {
+ return { min: this.min, max: this.max };
+ }
+ const ranges = (0, BiasNumericRange_1.biasNumericRange)(this.min, this.max, BiasNumericRange_1.bigIntLogLike);
+ if (ranges.length === 1) {
+ return ranges[0];
+ }
+ const id = mrng.nextInt(-2 * (ranges.length - 1), ranges.length - 2);
+ return id < 0 ? ranges[0] : ranges[id + 1];
+ }
+ canShrinkWithoutContext(value) {
+ return typeof value === 'bigint' && this.min <= value && value <= this.max;
+ }
+ shrink(current, context) {
+ if (!BigIntArbitrary.isValidContext(current, context)) {
+ const target = this.defaultTarget();
+ return (0, ShrinkBigInt_1.shrinkBigInt)(current, target, true);
+ }
+ if (this.isLastChanceTry(current, context)) {
+ return Stream_1.Stream.of(new Value_1.Value(context, undefined));
+ }
+ return (0, ShrinkBigInt_1.shrinkBigInt)(current, context, false);
+ }
+ defaultTarget() {
+ if (this.min <= 0 && this.max >= 0) {
+ return (0, globals_1.BigInt)(0);
+ }
+ return this.min < 0 ? this.max : this.min;
+ }
+ isLastChanceTry(current, context) {
+ if (current > 0)
+ return current === context + (0, globals_1.BigInt)(1) && current > this.min;
+ if (current < 0)
+ return current === context - (0, globals_1.BigInt)(1) && current < this.max;
+ return false;
+ }
+ static isValidContext(current, context) {
+ if (context === undefined) {
+ return false;
+ }
+ if (typeof context !== 'bigint') {
+ throw new Error(`Invalid context type passed to BigIntArbitrary (#1)`);
+ }
+ const differentSigns = (current > 0 && context < 0) || (current < 0 && context > 0);
+ if (context !== (0, globals_1.BigInt)(0) && differentSigns) {
+ throw new Error(`Invalid context value passed to BigIntArbitrary (#2)`);
+ }
+ return true;
+ }
+}
+exports.BigIntArbitrary = BigIntArbitrary;
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/CloneArbitrary.js b/node_modules/fast-check/lib/arbitrary/_internals/CloneArbitrary.js
new file mode 100644
index 0000000000000000000000000000000000000000..409d823045f79e5c48dce3fc30b0ab385d18e382
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/CloneArbitrary.js
@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloneArbitrary = void 0;
+const Arbitrary_1 = require("../../check/arbitrary/definition/Arbitrary");
+const Value_1 = require("../../check/arbitrary/definition/Value");
+const symbols_1 = require("../../check/symbols");
+const Stream_1 = require("../../stream/Stream");
+const globals_1 = require("../../utils/globals");
+const safeSymbolIterator = Symbol.iterator;
+const safeIsArray = Array.isArray;
+const safeObjectIs = Object.is;
+class CloneArbitrary extends Arbitrary_1.Arbitrary {
+ constructor(arb, numValues) {
+ super();
+ this.arb = arb;
+ this.numValues = numValues;
+ }
+ generate(mrng, biasFactor) {
+ const items = [];
+ if (this.numValues <= 0) {
+ return this.wrapper(items);
+ }
+ for (let idx = 0; idx !== this.numValues - 1; ++idx) {
+ (0, globals_1.safePush)(items, this.arb.generate(mrng.clone(), biasFactor));
+ }
+ (0, globals_1.safePush)(items, this.arb.generate(mrng, biasFactor));
+ return this.wrapper(items);
+ }
+ canShrinkWithoutContext(value) {
+ if (!safeIsArray(value) || value.length !== this.numValues) {
+ return false;
+ }
+ if (value.length === 0) {
+ return true;
+ }
+ for (let index = 1; index < value.length; ++index) {
+ if (!safeObjectIs(value[0], value[index])) {
+ return false;
+ }
+ }
+ return this.arb.canShrinkWithoutContext(value[0]);
+ }
+ shrink(value, context) {
+ if (value.length === 0) {
+ return Stream_1.Stream.nil();
+ }
+ return new Stream_1.Stream(this.shrinkImpl(value, context !== undefined ? context : [])).map((v) => this.wrapper(v));
+ }
+ *shrinkImpl(value, contexts) {
+ const its = (0, globals_1.safeMap)(value, (v, idx) => this.arb.shrink(v, contexts[idx])[safeSymbolIterator]());
+ let cur = (0, globals_1.safeMap)(its, (it) => it.next());
+ while (!cur[0].done) {
+ yield (0, globals_1.safeMap)(cur, (c) => c.value);
+ cur = (0, globals_1.safeMap)(its, (it) => it.next());
+ }
+ }
+ static makeItCloneable(vs, shrinkables) {
+ vs[symbols_1.cloneMethod] = () => {
+ const cloned = [];
+ for (let idx = 0; idx !== shrinkables.length; ++idx) {
+ (0, globals_1.safePush)(cloned, shrinkables[idx].value);
+ }
+ this.makeItCloneable(cloned, shrinkables);
+ return cloned;
+ };
+ return vs;
+ }
+ wrapper(items) {
+ let cloneable = false;
+ const vs = [];
+ const contexts = [];
+ for (let idx = 0; idx !== items.length; ++idx) {
+ const s = items[idx];
+ cloneable = cloneable || s.hasToBeCloned;
+ (0, globals_1.safePush)(vs, s.value);
+ (0, globals_1.safePush)(contexts, s.context);
+ }
+ if (cloneable) {
+ CloneArbitrary.makeItCloneable(vs, items);
+ }
+ return new Value_1.Value(vs, contexts);
+ }
+}
+exports.CloneArbitrary = CloneArbitrary;
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/CommandsArbitrary.js b/node_modules/fast-check/lib/arbitrary/_internals/CommandsArbitrary.js
new file mode 100644
index 0000000000000000000000000000000000000000..3e6cc1fe2f36d9ab56b5bd4f24bb4d79d7d3719b
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/CommandsArbitrary.js
@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandsArbitrary = void 0;
+const Arbitrary_1 = require("../../check/arbitrary/definition/Arbitrary");
+const Value_1 = require("../../check/arbitrary/definition/Value");
+const CommandsIterable_1 = require("../../check/model/commands/CommandsIterable");
+const CommandWrapper_1 = require("../../check/model/commands/CommandWrapper");
+const ReplayPath_1 = require("../../check/model/ReplayPath");
+const LazyIterableIterator_1 = require("../../stream/LazyIterableIterator");
+const Stream_1 = require("../../stream/Stream");
+const oneof_1 = require("../oneof");
+const RestrictedIntegerArbitraryBuilder_1 = require("./builders/RestrictedIntegerArbitraryBuilder");
+class CommandsArbitrary extends Arbitrary_1.Arbitrary {
+ constructor(commandArbs, maxGeneratedCommands, maxCommands, sourceReplayPath, disableReplayLog) {
+ super();
+ this.sourceReplayPath = sourceReplayPath;
+ this.disableReplayLog = disableReplayLog;
+ this.oneCommandArb = (0, oneof_1.oneof)(...commandArbs).map((c) => new CommandWrapper_1.CommandWrapper(c));
+ this.lengthArb = (0, RestrictedIntegerArbitraryBuilder_1.restrictedIntegerArbitraryBuilder)(0, maxGeneratedCommands, maxCommands);
+ this.replayPath = [];
+ this.replayPathPosition = 0;
+ }
+ metadataForReplay() {
+ return this.disableReplayLog ? '' : `replayPath=${JSON.stringify(ReplayPath_1.ReplayPath.stringify(this.replayPath))}`;
+ }
+ buildValueFor(items, shrunkOnce) {
+ const commands = items.map((item) => item.value_);
+ const context = { shrunkOnce, items };
+ return new Value_1.Value(new CommandsIterable_1.CommandsIterable(commands, () => this.metadataForReplay()), context);
+ }
+ generate(mrng) {
+ const size = this.lengthArb.generate(mrng, undefined);
+ const sizeValue = size.value;
+ const items = Array(sizeValue);
+ for (let idx = 0; idx !== sizeValue; ++idx) {
+ const item = this.oneCommandArb.generate(mrng, undefined);
+ items[idx] = item;
+ }
+ this.replayPathPosition = 0;
+ return this.buildValueFor(items, false);
+ }
+ canShrinkWithoutContext(value) {
+ return false;
+ }
+ filterOnExecution(itemsRaw) {
+ const items = [];
+ for (const c of itemsRaw) {
+ if (c.value_.hasRan) {
+ this.replayPath.push(true);
+ items.push(c);
+ }
+ else
+ this.replayPath.push(false);
+ }
+ return items;
+ }
+ filterOnReplay(itemsRaw) {
+ return itemsRaw.filter((c, idx) => {
+ const state = this.replayPath[this.replayPathPosition + idx];
+ if (state === undefined)
+ throw new Error(`Too short replayPath`);
+ if (!state && c.value_.hasRan)
+ throw new Error(`Mismatch between replayPath and real execution`);
+ return state;
+ });
+ }
+ filterForShrinkImpl(itemsRaw) {
+ if (this.replayPathPosition === 0) {
+ this.replayPath = this.sourceReplayPath !== null ? ReplayPath_1.ReplayPath.parse(this.sourceReplayPath) : [];
+ }
+ const items = this.replayPathPosition < this.replayPath.length
+ ? this.filterOnReplay(itemsRaw)
+ : this.filterOnExecution(itemsRaw);
+ this.replayPathPosition += itemsRaw.length;
+ return items;
+ }
+ shrink(_value, context) {
+ if (context === undefined) {
+ return Stream_1.Stream.nil();
+ }
+ const safeContext = context;
+ const shrunkOnce = safeContext.shrunkOnce;
+ const itemsRaw = safeContext.items;
+ const items = this.filterForShrinkImpl(itemsRaw);
+ if (items.length === 0) {
+ return Stream_1.Stream.nil();
+ }
+ const rootShrink = shrunkOnce
+ ? Stream_1.Stream.nil()
+ : new Stream_1.Stream([[]][Symbol.iterator]());
+ const nextShrinks = [];
+ for (let numToKeep = 0; numToKeep !== items.length; ++numToKeep) {
+ nextShrinks.push((0, LazyIterableIterator_1.makeLazy)(() => {
+ const fixedStart = items.slice(0, numToKeep);
+ return this.lengthArb
+ .shrink(items.length - 1 - numToKeep, undefined)
+ .map((l) => fixedStart.concat(items.slice(items.length - (l.value + 1))));
+ }));
+ }
+ for (let itemAt = 0; itemAt !== items.length; ++itemAt) {
+ nextShrinks.push((0, LazyIterableIterator_1.makeLazy)(() => this.oneCommandArb
+ .shrink(items[itemAt].value_, items[itemAt].context)
+ .map((v) => items.slice(0, itemAt).concat([v], items.slice(itemAt + 1)))));
+ }
+ return rootShrink.join(...nextShrinks).map((shrinkables) => {
+ return this.buildValueFor(shrinkables.map((c) => new Value_1.Value(c.value_.clone(), c.context)), true);
+ });
+ }
+}
+exports.CommandsArbitrary = CommandsArbitrary;
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/ConstantArbitrary.js b/node_modules/fast-check/lib/arbitrary/_internals/ConstantArbitrary.js
new file mode 100644
index 0000000000000000000000000000000000000000..95d62afa1b4f41dcc27e0ac65a0678bcb860fd1c
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/ConstantArbitrary.js
@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstantArbitrary = void 0;
+const Stream_1 = require("../../stream/Stream");
+const Arbitrary_1 = require("../../check/arbitrary/definition/Arbitrary");
+const Value_1 = require("../../check/arbitrary/definition/Value");
+const symbols_1 = require("../../check/symbols");
+const globals_1 = require("../../utils/globals");
+const safeObjectIs = Object.is;
+class ConstantArbitrary extends Arbitrary_1.Arbitrary {
+ constructor(values) {
+ super();
+ this.values = values;
+ }
+ generate(mrng, _biasFactor) {
+ const idx = this.values.length === 1 ? 0 : mrng.nextInt(0, this.values.length - 1);
+ const value = this.values[idx];
+ if (!(0, symbols_1.hasCloneMethod)(value)) {
+ return new Value_1.Value(value, idx);
+ }
+ return new Value_1.Value(value, idx, () => value[symbols_1.cloneMethod]());
+ }
+ canShrinkWithoutContext(value) {
+ if (this.values.length === 1) {
+ return safeObjectIs(this.values[0], value);
+ }
+ if (this.fastValues === undefined) {
+ this.fastValues = new FastConstantValuesLookup(this.values);
+ }
+ return this.fastValues.has(value);
+ }
+ shrink(value, context) {
+ if (context === 0 || safeObjectIs(value, this.values[0])) {
+ return Stream_1.Stream.nil();
+ }
+ return Stream_1.Stream.of(new Value_1.Value(this.values[0], 0));
+ }
+}
+exports.ConstantArbitrary = ConstantArbitrary;
+class FastConstantValuesLookup {
+ constructor(values) {
+ this.values = values;
+ this.fastValues = new globals_1.Set(this.values);
+ let hasMinusZero = false;
+ let hasPlusZero = false;
+ if ((0, globals_1.safeHas)(this.fastValues, 0)) {
+ for (let idx = 0; idx !== this.values.length; ++idx) {
+ const value = this.values[idx];
+ hasMinusZero = hasMinusZero || safeObjectIs(value, -0);
+ hasPlusZero = hasPlusZero || safeObjectIs(value, 0);
+ }
+ }
+ this.hasMinusZero = hasMinusZero;
+ this.hasPlusZero = hasPlusZero;
+ }
+ has(value) {
+ if (value === 0) {
+ if (safeObjectIs(value, 0)) {
+ return this.hasPlusZero;
+ }
+ return this.hasMinusZero;
+ }
+ return (0, globals_1.safeHas)(this.fastValues, value);
+ }
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/FrequencyArbitrary.js b/node_modules/fast-check/lib/arbitrary/_internals/FrequencyArbitrary.js
new file mode 100644
index 0000000000000000000000000000000000000000..a2b9fe97040f0d7cd898b822acd26f4dabf78096
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/FrequencyArbitrary.js
@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FrequencyArbitrary = void 0;
+const Stream_1 = require("../../stream/Stream");
+const Arbitrary_1 = require("../../check/arbitrary/definition/Arbitrary");
+const Value_1 = require("../../check/arbitrary/definition/Value");
+const DepthContext_1 = require("./helpers/DepthContext");
+const MaxLengthFromMinLength_1 = require("./helpers/MaxLengthFromMinLength");
+const globals_1 = require("../../utils/globals");
+const safePositiveInfinity = Number.POSITIVE_INFINITY;
+const safeMaxSafeInteger = Number.MAX_SAFE_INTEGER;
+const safeNumberIsInteger = Number.isInteger;
+const safeMathFloor = Math.floor;
+const safeMathPow = Math.pow;
+const safeMathMin = Math.min;
+class FrequencyArbitrary extends Arbitrary_1.Arbitrary {
+ static from(warbs, constraints, label) {
+ if (warbs.length === 0) {
+ throw new Error(`${label} expects at least one weighted arbitrary`);
+ }
+ let totalWeight = 0;
+ for (let idx = 0; idx !== warbs.length; ++idx) {
+ const currentArbitrary = warbs[idx].arbitrary;
+ if (currentArbitrary === undefined) {
+ throw new Error(`${label} expects arbitraries to be specified`);
+ }
+ const currentWeight = warbs[idx].weight;
+ totalWeight += currentWeight;
+ if (!safeNumberIsInteger(currentWeight)) {
+ throw new Error(`${label} expects weights to be integer values`);
+ }
+ if (currentWeight < 0) {
+ throw new Error(`${label} expects weights to be superior or equal to 0`);
+ }
+ }
+ if (totalWeight <= 0) {
+ throw new Error(`${label} expects the sum of weights to be strictly superior to 0`);
+ }
+ const sanitizedConstraints = {
+ depthBias: (0, MaxLengthFromMinLength_1.depthBiasFromSizeForArbitrary)(constraints.depthSize, constraints.maxDepth !== undefined),
+ maxDepth: constraints.maxDepth != undefined ? constraints.maxDepth : safePositiveInfinity,
+ withCrossShrink: !!constraints.withCrossShrink,
+ };
+ return new FrequencyArbitrary(warbs, sanitizedConstraints, (0, DepthContext_1.getDepthContextFor)(constraints.depthIdentifier));
+ }
+ constructor(warbs, constraints, context) {
+ super();
+ this.warbs = warbs;
+ this.constraints = constraints;
+ this.context = context;
+ let currentWeight = 0;
+ this.cumulatedWeights = [];
+ for (let idx = 0; idx !== warbs.length; ++idx) {
+ currentWeight += warbs[idx].weight;
+ (0, globals_1.safePush)(this.cumulatedWeights, currentWeight);
+ }
+ this.totalWeight = currentWeight;
+ }
+ generate(mrng, biasFactor) {
+ if (this.mustGenerateFirst()) {
+ return this.safeGenerateForIndex(mrng, 0, biasFactor);
+ }
+ const selected = mrng.nextInt(this.computeNegDepthBenefit(), this.totalWeight - 1);
+ for (let idx = 0; idx !== this.cumulatedWeights.length; ++idx) {
+ if (selected < this.cumulatedWeights[idx]) {
+ return this.safeGenerateForIndex(mrng, idx, biasFactor);
+ }
+ }
+ throw new Error(`Unable to generate from fc.frequency`);
+ }
+ canShrinkWithoutContext(value) {
+ return this.canShrinkWithoutContextIndex(value) !== -1;
+ }
+ shrink(value, context) {
+ if (context !== undefined) {
+ const safeContext = context;
+ const selectedIndex = safeContext.selectedIndex;
+ const originalBias = safeContext.originalBias;
+ const originalArbitrary = this.warbs[selectedIndex].arbitrary;
+ const originalShrinks = originalArbitrary
+ .shrink(value, safeContext.originalContext)
+ .map((v) => this.mapIntoValue(selectedIndex, v, null, originalBias));
+ if (safeContext.clonedMrngForFallbackFirst !== null) {
+ if (safeContext.cachedGeneratedForFirst === undefined) {
+ safeContext.cachedGeneratedForFirst = this.safeGenerateForIndex(safeContext.clonedMrngForFallbackFirst, 0, originalBias);
+ }
+ const valueFromFirst = safeContext.cachedGeneratedForFirst;
+ return Stream_1.Stream.of(valueFromFirst).join(originalShrinks);
+ }
+ return originalShrinks;
+ }
+ const potentialSelectedIndex = this.canShrinkWithoutContextIndex(value);
+ if (potentialSelectedIndex === -1) {
+ return Stream_1.Stream.nil();
+ }
+ return this.defaultShrinkForFirst(potentialSelectedIndex).join(this.warbs[potentialSelectedIndex].arbitrary
+ .shrink(value, undefined)
+ .map((v) => this.mapIntoValue(potentialSelectedIndex, v, null, undefined)));
+ }
+ defaultShrinkForFirst(selectedIndex) {
+ ++this.context.depth;
+ try {
+ if (!this.mustFallbackToFirstInShrink(selectedIndex) || this.warbs[0].fallbackValue === undefined) {
+ return Stream_1.Stream.nil();
+ }
+ }
+ finally {
+ --this.context.depth;
+ }
+ const rawShrinkValue = new Value_1.Value(this.warbs[0].fallbackValue.default, undefined);
+ return Stream_1.Stream.of(this.mapIntoValue(0, rawShrinkValue, null, undefined));
+ }
+ canShrinkWithoutContextIndex(value) {
+ if (this.mustGenerateFirst()) {
+ return this.warbs[0].arbitrary.canShrinkWithoutContext(value) ? 0 : -1;
+ }
+ try {
+ ++this.context.depth;
+ for (let idx = 0; idx !== this.warbs.length; ++idx) {
+ const warb = this.warbs[idx];
+ if (warb.weight !== 0 && warb.arbitrary.canShrinkWithoutContext(value)) {
+ return idx;
+ }
+ }
+ return -1;
+ }
+ finally {
+ --this.context.depth;
+ }
+ }
+ mapIntoValue(idx, value, clonedMrngForFallbackFirst, biasFactor) {
+ const context = {
+ selectedIndex: idx,
+ originalBias: biasFactor,
+ originalContext: value.context,
+ clonedMrngForFallbackFirst,
+ };
+ return new Value_1.Value(value.value, context);
+ }
+ safeGenerateForIndex(mrng, idx, biasFactor) {
+ ++this.context.depth;
+ try {
+ const value = this.warbs[idx].arbitrary.generate(mrng, biasFactor);
+ const clonedMrngForFallbackFirst = this.mustFallbackToFirstInShrink(idx) ? mrng.clone() : null;
+ return this.mapIntoValue(idx, value, clonedMrngForFallbackFirst, biasFactor);
+ }
+ finally {
+ --this.context.depth;
+ }
+ }
+ mustGenerateFirst() {
+ return this.constraints.maxDepth <= this.context.depth;
+ }
+ mustFallbackToFirstInShrink(idx) {
+ return idx !== 0 && this.constraints.withCrossShrink && this.warbs[0].weight !== 0;
+ }
+ computeNegDepthBenefit() {
+ const depthBias = this.constraints.depthBias;
+ if (depthBias <= 0 || this.warbs[0].weight === 0) {
+ return 0;
+ }
+ const depthBenefit = safeMathFloor(safeMathPow(1 + depthBias, this.context.depth)) - 1;
+ return -safeMathMin(this.totalWeight * depthBenefit, safeMaxSafeInteger) || 0;
+ }
+}
+exports.FrequencyArbitrary = FrequencyArbitrary;
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/GeneratorArbitrary.js b/node_modules/fast-check/lib/arbitrary/_internals/GeneratorArbitrary.js
new file mode 100644
index 0000000000000000000000000000000000000000..ad69a78eceeb5685c2c28df44760af7769b19795
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/GeneratorArbitrary.js
@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeneratorArbitrary = void 0;
+const Arbitrary_1 = require("../../check/arbitrary/definition/Arbitrary");
+const Stream_1 = require("../../stream/Stream");
+const globals_1 = require("../../utils/globals");
+const GeneratorValueBuilder_1 = require("./builders/GeneratorValueBuilder");
+const StableArbitraryGeneratorCache_1 = require("./builders/StableArbitraryGeneratorCache");
+const TupleArbitrary_1 = require("./TupleArbitrary");
+class GeneratorArbitrary extends Arbitrary_1.Arbitrary {
+ constructor() {
+ super(...arguments);
+ this.arbitraryCache = (0, StableArbitraryGeneratorCache_1.buildStableArbitraryGeneratorCache)(StableArbitraryGeneratorCache_1.naiveIsEqual);
+ }
+ generate(mrng, biasFactor) {
+ return (0, GeneratorValueBuilder_1.buildGeneratorValue)(mrng, biasFactor, () => [], this.arbitraryCache);
+ }
+ canShrinkWithoutContext(value) {
+ return false;
+ }
+ shrink(_value, context) {
+ if (context === undefined) {
+ return Stream_1.Stream.nil();
+ }
+ const safeContext = context;
+ const mrng = safeContext.mrng;
+ const biasFactor = safeContext.biasFactor;
+ const history = safeContext.history;
+ return (0, TupleArbitrary_1.tupleShrink)(history.map((c) => c.arb), history.map((c) => c.value), history.map((c) => c.context)).map((shrink) => {
+ function computePreBuiltValues() {
+ const subValues = shrink.value;
+ const subContexts = shrink.context;
+ return (0, globals_1.safeMap)(history, (entry, index) => ({
+ arb: entry.arb,
+ value: subValues[index],
+ context: subContexts[index],
+ mrng: entry.mrng,
+ }));
+ }
+ return (0, GeneratorValueBuilder_1.buildGeneratorValue)(mrng, biasFactor, computePreBuiltValues, this.arbitraryCache);
+ });
+ }
+}
+exports.GeneratorArbitrary = GeneratorArbitrary;
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/IntegerArbitrary.js b/node_modules/fast-check/lib/arbitrary/_internals/IntegerArbitrary.js
new file mode 100644
index 0000000000000000000000000000000000000000..57050d73f7ad2f5551eb97cb85eca46332c79b07
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/IntegerArbitrary.js
@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntegerArbitrary = void 0;
+const Arbitrary_1 = require("../../check/arbitrary/definition/Arbitrary");
+const Value_1 = require("../../check/arbitrary/definition/Value");
+const Stream_1 = require("../../stream/Stream");
+const BiasNumericRange_1 = require("./helpers/BiasNumericRange");
+const ShrinkInteger_1 = require("./helpers/ShrinkInteger");
+const safeMathSign = Math.sign;
+const safeNumberIsInteger = Number.isInteger;
+const safeObjectIs = Object.is;
+class IntegerArbitrary extends Arbitrary_1.Arbitrary {
+ constructor(min, max) {
+ super();
+ this.min = min;
+ this.max = max;
+ }
+ generate(mrng, biasFactor) {
+ const range = this.computeGenerateRange(mrng, biasFactor);
+ return new Value_1.Value(mrng.nextInt(range.min, range.max), undefined);
+ }
+ canShrinkWithoutContext(value) {
+ return (typeof value === 'number' &&
+ safeNumberIsInteger(value) &&
+ !safeObjectIs(value, -0) &&
+ this.min <= value &&
+ value <= this.max);
+ }
+ shrink(current, context) {
+ if (!IntegerArbitrary.isValidContext(current, context)) {
+ const target = this.defaultTarget();
+ return (0, ShrinkInteger_1.shrinkInteger)(current, target, true);
+ }
+ if (this.isLastChanceTry(current, context)) {
+ return Stream_1.Stream.of(new Value_1.Value(context, undefined));
+ }
+ return (0, ShrinkInteger_1.shrinkInteger)(current, context, false);
+ }
+ defaultTarget() {
+ if (this.min <= 0 && this.max >= 0) {
+ return 0;
+ }
+ return this.min < 0 ? this.max : this.min;
+ }
+ computeGenerateRange(mrng, biasFactor) {
+ if (biasFactor === undefined || mrng.nextInt(1, biasFactor) !== 1) {
+ return { min: this.min, max: this.max };
+ }
+ const ranges = (0, BiasNumericRange_1.biasNumericRange)(this.min, this.max, BiasNumericRange_1.integerLogLike);
+ if (ranges.length === 1) {
+ return ranges[0];
+ }
+ const id = mrng.nextInt(-2 * (ranges.length - 1), ranges.length - 2);
+ return id < 0 ? ranges[0] : ranges[id + 1];
+ }
+ isLastChanceTry(current, context) {
+ if (current > 0)
+ return current === context + 1 && current > this.min;
+ if (current < 0)
+ return current === context - 1 && current < this.max;
+ return false;
+ }
+ static isValidContext(current, context) {
+ if (context === undefined) {
+ return false;
+ }
+ if (typeof context !== 'number') {
+ throw new Error(`Invalid context type passed to IntegerArbitrary (#1)`);
+ }
+ if (context !== 0 && safeMathSign(current) !== safeMathSign(context)) {
+ throw new Error(`Invalid context value passed to IntegerArbitrary (#2)`);
+ }
+ return true;
+ }
+}
+exports.IntegerArbitrary = IntegerArbitrary;
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/LazyArbitrary.js b/node_modules/fast-check/lib/arbitrary/_internals/LazyArbitrary.js
new file mode 100644
index 0000000000000000000000000000000000000000..f9dbfc7fe7b60a5f9c673c02f6bcd8b0801604ce
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/LazyArbitrary.js
@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LazyArbitrary = void 0;
+const Arbitrary_1 = require("../../check/arbitrary/definition/Arbitrary");
+class LazyArbitrary extends Arbitrary_1.Arbitrary {
+ constructor(name) {
+ super();
+ this.name = name;
+ this.underlying = null;
+ }
+ generate(mrng, biasFactor) {
+ if (!this.underlying) {
+ throw new Error(`Lazy arbitrary ${JSON.stringify(this.name)} not correctly initialized`);
+ }
+ return this.underlying.generate(mrng, biasFactor);
+ }
+ canShrinkWithoutContext(value) {
+ if (!this.underlying) {
+ throw new Error(`Lazy arbitrary ${JSON.stringify(this.name)} not correctly initialized`);
+ }
+ return this.underlying.canShrinkWithoutContext(value);
+ }
+ shrink(value, context) {
+ if (!this.underlying) {
+ throw new Error(`Lazy arbitrary ${JSON.stringify(this.name)} not correctly initialized`);
+ }
+ return this.underlying.shrink(value, context);
+ }
+}
+exports.LazyArbitrary = LazyArbitrary;
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/LimitedShrinkArbitrary.js b/node_modules/fast-check/lib/arbitrary/_internals/LimitedShrinkArbitrary.js
new file mode 100644
index 0000000000000000000000000000000000000000..e78f04563c35665f1ae898c38523859ee3e4ded1
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/LimitedShrinkArbitrary.js
@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LimitedShrinkArbitrary = void 0;
+const Arbitrary_1 = require("../../check/arbitrary/definition/Arbitrary");
+const Value_1 = require("../../check/arbitrary/definition/Value");
+const Stream_1 = require("../../stream/Stream");
+const ZipIterableIterators_1 = require("./helpers/ZipIterableIterators");
+function* iotaFrom(startValue) {
+ let value = startValue;
+ while (true) {
+ yield value;
+ ++value;
+ }
+}
+class LimitedShrinkArbitrary extends Arbitrary_1.Arbitrary {
+ constructor(arb, maxShrinks) {
+ super();
+ this.arb = arb;
+ this.maxShrinks = maxShrinks;
+ }
+ generate(mrng, biasFactor) {
+ const value = this.arb.generate(mrng, biasFactor);
+ return this.valueMapper(value, 0);
+ }
+ canShrinkWithoutContext(value) {
+ return this.arb.canShrinkWithoutContext(value);
+ }
+ shrink(value, context) {
+ if (this.isSafeContext(context)) {
+ return this.safeShrink(value, context.originalContext, context.length);
+ }
+ return this.safeShrink(value, undefined, 0);
+ }
+ safeShrink(value, originalContext, currentLength) {
+ const remaining = this.maxShrinks - currentLength;
+ if (remaining <= 0) {
+ return Stream_1.Stream.nil();
+ }
+ return new Stream_1.Stream((0, ZipIterableIterators_1.zipIterableIterators)(this.arb.shrink(value, originalContext), iotaFrom(currentLength + 1)))
+ .take(remaining)
+ .map((valueAndLength) => this.valueMapper(valueAndLength[0], valueAndLength[1]));
+ }
+ valueMapper(v, newLength) {
+ const context = { originalContext: v.context, length: newLength };
+ return new Value_1.Value(v.value, context);
+ }
+ isSafeContext(context) {
+ return (context != null &&
+ typeof context === 'object' &&
+ 'originalContext' in context &&
+ 'length' in context);
+ }
+}
+exports.LimitedShrinkArbitrary = LimitedShrinkArbitrary;
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/MixedCaseArbitrary.js b/node_modules/fast-check/lib/arbitrary/_internals/MixedCaseArbitrary.js
new file mode 100644
index 0000000000000000000000000000000000000000..9e71a90c4b546541ed9567ea5632afb3b93457e5
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/MixedCaseArbitrary.js
@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MixedCaseArbitrary = void 0;
+const bigUintN_1 = require("../bigUintN");
+const Arbitrary_1 = require("../../check/arbitrary/definition/Arbitrary");
+const Value_1 = require("../../check/arbitrary/definition/Value");
+const LazyIterableIterator_1 = require("../../stream/LazyIterableIterator");
+const ToggleFlags_1 = require("./helpers/ToggleFlags");
+const globals_1 = require("../../utils/globals");
+const globals_2 = require("../../utils/globals");
+class MixedCaseArbitrary extends Arbitrary_1.Arbitrary {
+ constructor(stringArb, toggleCase, untoggleAll) {
+ super();
+ this.stringArb = stringArb;
+ this.toggleCase = toggleCase;
+ this.untoggleAll = untoggleAll;
+ }
+ buildContextFor(rawStringValue, flagsValue) {
+ return {
+ rawString: rawStringValue.value,
+ rawStringContext: rawStringValue.context,
+ flags: flagsValue.value,
+ flagsContext: flagsValue.context,
+ };
+ }
+ generate(mrng, biasFactor) {
+ const rawStringValue = this.stringArb.generate(mrng, biasFactor);
+ const chars = [...rawStringValue.value];
+ const togglePositions = (0, ToggleFlags_1.computeTogglePositions)(chars, this.toggleCase);
+ const flagsArb = (0, bigUintN_1.bigUintN)(togglePositions.length);
+ const flagsValue = flagsArb.generate(mrng, undefined);
+ (0, ToggleFlags_1.applyFlagsOnChars)(chars, flagsValue.value, togglePositions, this.toggleCase);
+ return new Value_1.Value((0, globals_1.safeJoin)(chars, ''), this.buildContextFor(rawStringValue, flagsValue));
+ }
+ canShrinkWithoutContext(value) {
+ if (typeof value !== 'string') {
+ return false;
+ }
+ return this.untoggleAll !== undefined
+ ? this.stringArb.canShrinkWithoutContext(this.untoggleAll(value))
+ :
+ this.stringArb.canShrinkWithoutContext(value);
+ }
+ shrink(value, context) {
+ let contextSafe;
+ if (context !== undefined) {
+ contextSafe = context;
+ }
+ else {
+ if (this.untoggleAll !== undefined) {
+ const untoggledValue = this.untoggleAll(value);
+ const valueChars = [...value];
+ const untoggledValueChars = [...untoggledValue];
+ const togglePositions = (0, ToggleFlags_1.computeTogglePositions)(untoggledValueChars, this.toggleCase);
+ contextSafe = {
+ rawString: untoggledValue,
+ rawStringContext: undefined,
+ flags: (0, ToggleFlags_1.computeFlagsFromChars)(untoggledValueChars, valueChars, togglePositions),
+ flagsContext: undefined,
+ };
+ }
+ else {
+ contextSafe = {
+ rawString: value,
+ rawStringContext: undefined,
+ flags: (0, globals_2.BigInt)(0),
+ flagsContext: undefined,
+ };
+ }
+ }
+ const rawString = contextSafe.rawString;
+ const flags = contextSafe.flags;
+ return this.stringArb
+ .shrink(rawString, contextSafe.rawStringContext)
+ .map((nRawStringValue) => {
+ const nChars = [...nRawStringValue.value];
+ const nTogglePositions = (0, ToggleFlags_1.computeTogglePositions)(nChars, this.toggleCase);
+ const nFlags = (0, ToggleFlags_1.computeNextFlags)(flags, nTogglePositions.length);
+ (0, ToggleFlags_1.applyFlagsOnChars)(nChars, nFlags, nTogglePositions, this.toggleCase);
+ return new Value_1.Value((0, globals_1.safeJoin)(nChars, ''), this.buildContextFor(nRawStringValue, new Value_1.Value(nFlags, undefined)));
+ })
+ .join((0, LazyIterableIterator_1.makeLazy)(() => {
+ const chars = [...rawString];
+ const togglePositions = (0, ToggleFlags_1.computeTogglePositions)(chars, this.toggleCase);
+ return (0, bigUintN_1.bigUintN)(togglePositions.length)
+ .shrink(flags, contextSafe.flagsContext)
+ .map((nFlagsValue) => {
+ const nChars = (0, globals_1.safeSlice)(chars);
+ (0, ToggleFlags_1.applyFlagsOnChars)(nChars, nFlagsValue.value, togglePositions, this.toggleCase);
+ return new Value_1.Value((0, globals_1.safeJoin)(nChars, ''), this.buildContextFor(new Value_1.Value(rawString, contextSafe.rawStringContext), nFlagsValue));
+ });
+ }));
+ }
+}
+exports.MixedCaseArbitrary = MixedCaseArbitrary;
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/SchedulerArbitrary.js b/node_modules/fast-check/lib/arbitrary/_internals/SchedulerArbitrary.js
new file mode 100644
index 0000000000000000000000000000000000000000..832f28c1a07842af4d894e637d3efc277bd9a101
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/SchedulerArbitrary.js
@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchedulerArbitrary = void 0;
+const Arbitrary_1 = require("../../check/arbitrary/definition/Arbitrary");
+const Value_1 = require("../../check/arbitrary/definition/Value");
+const Stream_1 = require("../../stream/Stream");
+const SchedulerImplem_1 = require("./implementations/SchedulerImplem");
+function buildNextTaskIndex(mrng) {
+ const clonedMrng = mrng.clone();
+ return {
+ clone: () => buildNextTaskIndex(clonedMrng),
+ nextTaskIndex: (scheduledTasks) => {
+ return mrng.nextInt(0, scheduledTasks.length - 1);
+ },
+ };
+}
+class SchedulerArbitrary extends Arbitrary_1.Arbitrary {
+ constructor(act) {
+ super();
+ this.act = act;
+ }
+ generate(mrng, _biasFactor) {
+ return new Value_1.Value(new SchedulerImplem_1.SchedulerImplem(this.act, buildNextTaskIndex(mrng.clone())), undefined);
+ }
+ canShrinkWithoutContext(value) {
+ return false;
+ }
+ shrink(_value, _context) {
+ return Stream_1.Stream.nil();
+ }
+}
+exports.SchedulerArbitrary = SchedulerArbitrary;
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/StreamArbitrary.js b/node_modules/fast-check/lib/arbitrary/_internals/StreamArbitrary.js
new file mode 100644
index 0000000000000000000000000000000000000000..5c8172afa421641311929fad6e2205423e0ba0c9
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/StreamArbitrary.js
@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamArbitrary = void 0;
+const Arbitrary_1 = require("../../check/arbitrary/definition/Arbitrary");
+const Value_1 = require("../../check/arbitrary/definition/Value");
+const symbols_1 = require("../../check/symbols");
+const Stream_1 = require("../../stream/Stream");
+const globals_1 = require("../../utils/globals");
+const stringify_1 = require("../../utils/stringify");
+const safeObjectDefineProperties = Object.defineProperties;
+function prettyPrint(seenValuesStrings) {
+ return `Stream(${(0, globals_1.safeJoin)(seenValuesStrings, ',')}…)`;
+}
+class StreamArbitrary extends Arbitrary_1.Arbitrary {
+ constructor(arb) {
+ super();
+ this.arb = arb;
+ }
+ generate(mrng, biasFactor) {
+ const appliedBiasFactor = biasFactor !== undefined && mrng.nextInt(1, biasFactor) === 1 ? biasFactor : undefined;
+ const enrichedProducer = () => {
+ const seenValues = [];
+ const g = function* (arb, clonedMrng) {
+ while (true) {
+ const value = arb.generate(clonedMrng, appliedBiasFactor).value;
+ (0, globals_1.safePush)(seenValues, value);
+ yield value;
+ }
+ };
+ const s = new Stream_1.Stream(g(this.arb, mrng.clone()));
+ return safeObjectDefineProperties(s, {
+ toString: { value: () => prettyPrint(seenValues.map(stringify_1.stringify)) },
+ [stringify_1.toStringMethod]: { value: () => prettyPrint(seenValues.map(stringify_1.stringify)) },
+ [stringify_1.asyncToStringMethod]: { value: async () => prettyPrint(await Promise.all(seenValues.map(stringify_1.asyncStringify))) },
+ [symbols_1.cloneMethod]: { value: enrichedProducer, enumerable: true },
+ });
+ };
+ return new Value_1.Value(enrichedProducer(), undefined);
+ }
+ canShrinkWithoutContext(value) {
+ return false;
+ }
+ shrink(_value, _context) {
+ return Stream_1.Stream.nil();
+ }
+}
+exports.StreamArbitrary = StreamArbitrary;
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/StringUnitArbitrary.js b/node_modules/fast-check/lib/arbitrary/_internals/StringUnitArbitrary.js
new file mode 100644
index 0000000000000000000000000000000000000000..f823f80d117de159c174fd862d629ec859ca9d19
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/StringUnitArbitrary.js
@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringUnit = stringUnit;
+const globals_1 = require("../../utils/globals");
+const mapToConstant_1 = require("../mapToConstant");
+const GraphemeRanges_1 = require("./data/GraphemeRanges");
+const GraphemeRangesHelpers_1 = require("./helpers/GraphemeRangesHelpers");
+const registeredStringUnitInstancesMap = Object.create(null);
+function getAlphabetRanges(alphabet) {
+ switch (alphabet) {
+ case 'full':
+ return GraphemeRanges_1.fullAlphabetRanges;
+ case 'ascii':
+ return GraphemeRanges_1.asciiAlphabetRanges;
+ }
+}
+function getOrCreateStringUnitInstance(type, alphabet) {
+ const key = `${type}:${alphabet}`;
+ const registered = registeredStringUnitInstancesMap[key];
+ if (registered !== undefined) {
+ return registered;
+ }
+ const alphabetRanges = getAlphabetRanges(alphabet);
+ const ranges = type === 'binary' ? alphabetRanges : (0, GraphemeRangesHelpers_1.intersectGraphemeRanges)(alphabetRanges, GraphemeRanges_1.autonomousGraphemeRanges);
+ const entries = [];
+ for (const range of ranges) {
+ (0, globals_1.safePush)(entries, (0, GraphemeRangesHelpers_1.convertGraphemeRangeToMapToConstantEntry)(range));
+ }
+ if (type === 'grapheme') {
+ const decomposedRanges = (0, GraphemeRangesHelpers_1.intersectGraphemeRanges)(alphabetRanges, GraphemeRanges_1.autonomousDecomposableGraphemeRanges);
+ for (const range of decomposedRanges) {
+ const rawEntry = (0, GraphemeRangesHelpers_1.convertGraphemeRangeToMapToConstantEntry)(range);
+ (0, globals_1.safePush)(entries, {
+ num: rawEntry.num,
+ build: (idInGroup) => (0, globals_1.safeNormalize)(rawEntry.build(idInGroup), 'NFD'),
+ });
+ }
+ }
+ const stringUnitInstance = (0, mapToConstant_1.mapToConstant)(...entries);
+ registeredStringUnitInstancesMap[key] = stringUnitInstance;
+ return stringUnitInstance;
+}
+function stringUnit(type, alphabet) {
+ return getOrCreateStringUnitInstance(type, alphabet);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/SubarrayArbitrary.js b/node_modules/fast-check/lib/arbitrary/_internals/SubarrayArbitrary.js
new file mode 100644
index 0000000000000000000000000000000000000000..8ea873f0fd13411d179e1951380f87ba378021f2
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/SubarrayArbitrary.js
@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubarrayArbitrary = void 0;
+const Arbitrary_1 = require("../../check/arbitrary/definition/Arbitrary");
+const Value_1 = require("../../check/arbitrary/definition/Value");
+const LazyIterableIterator_1 = require("../../stream/LazyIterableIterator");
+const Stream_1 = require("../../stream/Stream");
+const globals_1 = require("../../utils/globals");
+const IsSubarrayOf_1 = require("./helpers/IsSubarrayOf");
+const IntegerArbitrary_1 = require("./IntegerArbitrary");
+const safeMathFloor = Math.floor;
+const safeMathLog = Math.log;
+const safeArrayIsArray = Array.isArray;
+class SubarrayArbitrary extends Arbitrary_1.Arbitrary {
+ constructor(originalArray, isOrdered, minLength, maxLength) {
+ super();
+ this.originalArray = originalArray;
+ this.isOrdered = isOrdered;
+ this.minLength = minLength;
+ this.maxLength = maxLength;
+ if (minLength < 0 || minLength > originalArray.length)
+ throw new Error('fc.*{s|S}ubarrayOf expects the minimal length to be between 0 and the size of the original array');
+ if (maxLength < 0 || maxLength > originalArray.length)
+ throw new Error('fc.*{s|S}ubarrayOf expects the maximal length to be between 0 and the size of the original array');
+ if (minLength > maxLength)
+ throw new Error('fc.*{s|S}ubarrayOf expects the minimal length to be inferior or equal to the maximal length');
+ this.lengthArb = new IntegerArbitrary_1.IntegerArbitrary(minLength, maxLength);
+ this.biasedLengthArb =
+ minLength !== maxLength
+ ? new IntegerArbitrary_1.IntegerArbitrary(minLength, minLength + safeMathFloor(safeMathLog(maxLength - minLength) / safeMathLog(2)))
+ : this.lengthArb;
+ }
+ generate(mrng, biasFactor) {
+ const lengthArb = biasFactor !== undefined && mrng.nextInt(1, biasFactor) === 1 ? this.biasedLengthArb : this.lengthArb;
+ const size = lengthArb.generate(mrng, undefined);
+ const sizeValue = size.value;
+ const remainingElements = (0, globals_1.safeMap)(this.originalArray, (_v, idx) => idx);
+ const ids = [];
+ for (let index = 0; index !== sizeValue; ++index) {
+ const selectedIdIndex = mrng.nextInt(0, remainingElements.length - 1);
+ (0, globals_1.safePush)(ids, remainingElements[selectedIdIndex]);
+ (0, globals_1.safeSplice)(remainingElements, selectedIdIndex, 1);
+ }
+ if (this.isOrdered) {
+ (0, globals_1.safeSort)(ids, (a, b) => a - b);
+ }
+ return new Value_1.Value((0, globals_1.safeMap)(ids, (i) => this.originalArray[i]), size.context);
+ }
+ canShrinkWithoutContext(value) {
+ if (!safeArrayIsArray(value)) {
+ return false;
+ }
+ if (!this.lengthArb.canShrinkWithoutContext(value.length)) {
+ return false;
+ }
+ return (0, IsSubarrayOf_1.isSubarrayOf)(this.originalArray, value);
+ }
+ shrink(value, context) {
+ if (value.length === 0) {
+ return Stream_1.Stream.nil();
+ }
+ return this.lengthArb
+ .shrink(value.length, context)
+ .map((newSize) => {
+ return new Value_1.Value((0, globals_1.safeSlice)(value, value.length - newSize.value), newSize.context);
+ })
+ .join(value.length > this.minLength
+ ? (0, LazyIterableIterator_1.makeLazy)(() => this.shrink((0, globals_1.safeSlice)(value, 1), undefined)
+ .filter((newValue) => this.minLength <= newValue.value.length + 1)
+ .map((newValue) => new Value_1.Value([value[0], ...newValue.value], undefined)))
+ : Stream_1.Stream.nil());
+ }
+}
+exports.SubarrayArbitrary = SubarrayArbitrary;
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/TupleArbitrary.js b/node_modules/fast-check/lib/arbitrary/_internals/TupleArbitrary.js
new file mode 100644
index 0000000000000000000000000000000000000000..f222d2c9a33520867aac423c0fa4190afc61d538
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/TupleArbitrary.js
@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TupleArbitrary = void 0;
+exports.tupleShrink = tupleShrink;
+const Stream_1 = require("../../stream/Stream");
+const symbols_1 = require("../../check/symbols");
+const Arbitrary_1 = require("../../check/arbitrary/definition/Arbitrary");
+const Value_1 = require("../../check/arbitrary/definition/Value");
+const globals_1 = require("../../utils/globals");
+const LazyIterableIterator_1 = require("../../stream/LazyIterableIterator");
+const safeArrayIsArray = Array.isArray;
+const safeObjectDefineProperty = Object.defineProperty;
+function tupleMakeItCloneable(vs, values) {
+ return safeObjectDefineProperty(vs, symbols_1.cloneMethod, {
+ value: () => {
+ const cloned = [];
+ for (let idx = 0; idx !== values.length; ++idx) {
+ (0, globals_1.safePush)(cloned, values[idx].value);
+ }
+ tupleMakeItCloneable(cloned, values);
+ return cloned;
+ },
+ });
+}
+function tupleWrapper(values) {
+ let cloneable = false;
+ const vs = [];
+ const ctxs = [];
+ for (let idx = 0; idx !== values.length; ++idx) {
+ const v = values[idx];
+ cloneable = cloneable || v.hasToBeCloned;
+ (0, globals_1.safePush)(vs, v.value);
+ (0, globals_1.safePush)(ctxs, v.context);
+ }
+ if (cloneable) {
+ tupleMakeItCloneable(vs, values);
+ }
+ return new Value_1.Value(vs, ctxs);
+}
+function tupleShrink(arbs, value, context) {
+ const shrinks = [];
+ const safeContext = safeArrayIsArray(context) ? context : [];
+ for (let idx = 0; idx !== arbs.length; ++idx) {
+ (0, globals_1.safePush)(shrinks, (0, LazyIterableIterator_1.makeLazy)(() => arbs[idx]
+ .shrink(value[idx], safeContext[idx])
+ .map((v) => {
+ const nextValues = (0, globals_1.safeMap)(value, (v, idx) => new Value_1.Value((0, symbols_1.cloneIfNeeded)(v), safeContext[idx]));
+ return [...(0, globals_1.safeSlice)(nextValues, 0, idx), v, ...(0, globals_1.safeSlice)(nextValues, idx + 1)];
+ })
+ .map(tupleWrapper)));
+ }
+ return Stream_1.Stream.nil().join(...shrinks);
+}
+class TupleArbitrary extends Arbitrary_1.Arbitrary {
+ constructor(arbs) {
+ super();
+ this.arbs = arbs;
+ for (let idx = 0; idx !== arbs.length; ++idx) {
+ const arb = arbs[idx];
+ if (arb == null || arb.generate == null)
+ throw new Error(`Invalid parameter encountered at index ${idx}: expecting an Arbitrary`);
+ }
+ }
+ generate(mrng, biasFactor) {
+ const mapped = [];
+ for (let idx = 0; idx !== this.arbs.length; ++idx) {
+ (0, globals_1.safePush)(mapped, this.arbs[idx].generate(mrng, biasFactor));
+ }
+ return tupleWrapper(mapped);
+ }
+ canShrinkWithoutContext(value) {
+ if (!safeArrayIsArray(value) || value.length !== this.arbs.length) {
+ return false;
+ }
+ for (let index = 0; index !== this.arbs.length; ++index) {
+ if (!this.arbs[index].canShrinkWithoutContext(value[index])) {
+ return false;
+ }
+ }
+ return true;
+ }
+ shrink(value, context) {
+ return tupleShrink(this.arbs, value, context);
+ }
+}
+exports.TupleArbitrary = TupleArbitrary;
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/WithShrinkFromOtherArbitrary.js b/node_modules/fast-check/lib/arbitrary/_internals/WithShrinkFromOtherArbitrary.js
new file mode 100644
index 0000000000000000000000000000000000000000..5ba1c3ef3104ecb41711b67f22be614cbe27279f
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/WithShrinkFromOtherArbitrary.js
@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WithShrinkFromOtherArbitrary = void 0;
+const Arbitrary_1 = require("../../check/arbitrary/definition/Arbitrary");
+const Value_1 = require("../../check/arbitrary/definition/Value");
+function isSafeContext(context) {
+ return context !== undefined;
+}
+function toGeneratorValue(value) {
+ if (value.hasToBeCloned) {
+ return new Value_1.Value(value.value_, { generatorContext: value.context }, () => value.value);
+ }
+ return new Value_1.Value(value.value_, { generatorContext: value.context });
+}
+function toShrinkerValue(value) {
+ if (value.hasToBeCloned) {
+ return new Value_1.Value(value.value_, { shrinkerContext: value.context }, () => value.value);
+ }
+ return new Value_1.Value(value.value_, { shrinkerContext: value.context });
+}
+class WithShrinkFromOtherArbitrary extends Arbitrary_1.Arbitrary {
+ constructor(generatorArbitrary, shrinkerArbitrary) {
+ super();
+ this.generatorArbitrary = generatorArbitrary;
+ this.shrinkerArbitrary = shrinkerArbitrary;
+ }
+ generate(mrng, biasFactor) {
+ return toGeneratorValue(this.generatorArbitrary.generate(mrng, biasFactor));
+ }
+ canShrinkWithoutContext(value) {
+ return this.shrinkerArbitrary.canShrinkWithoutContext(value);
+ }
+ shrink(value, context) {
+ if (!isSafeContext(context)) {
+ return this.shrinkerArbitrary.shrink(value, undefined).map(toShrinkerValue);
+ }
+ if ('generatorContext' in context) {
+ return this.generatorArbitrary.shrink(value, context.generatorContext).map(toGeneratorValue);
+ }
+ return this.shrinkerArbitrary.shrink(value, context.shrinkerContext).map(toShrinkerValue);
+ }
+}
+exports.WithShrinkFromOtherArbitrary = WithShrinkFromOtherArbitrary;
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/builders/AnyArbitraryBuilder.js b/node_modules/fast-check/lib/arbitrary/_internals/builders/AnyArbitraryBuilder.js
new file mode 100644
index 0000000000000000000000000000000000000000..f45a9af8e9631b3d5288036b4c4c68b47b85ffb2
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/builders/AnyArbitraryBuilder.js
@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.anyArbitraryBuilder = anyArbitraryBuilder;
+const stringify_1 = require("../../../utils/stringify");
+const array_1 = require("../../array");
+const oneof_1 = require("../../oneof");
+const tuple_1 = require("../../tuple");
+const bigInt_1 = require("../../bigInt");
+const date_1 = require("../../date");
+const float32Array_1 = require("../../float32Array");
+const float64Array_1 = require("../../float64Array");
+const int16Array_1 = require("../../int16Array");
+const int32Array_1 = require("../../int32Array");
+const int8Array_1 = require("../../int8Array");
+const uint16Array_1 = require("../../uint16Array");
+const uint32Array_1 = require("../../uint32Array");
+const uint8Array_1 = require("../../uint8Array");
+const uint8ClampedArray_1 = require("../../uint8ClampedArray");
+const sparseArray_1 = require("../../sparseArray");
+const ArrayToMap_1 = require("../mappers/ArrayToMap");
+const ArrayToSet_1 = require("../mappers/ArrayToSet");
+const letrec_1 = require("../../letrec");
+const uniqueArray_1 = require("../../uniqueArray");
+const DepthContext_1 = require("../helpers/DepthContext");
+const dictionary_1 = require("../../dictionary");
+function mapOf(ka, va, maxKeys, size, depthIdentifier) {
+ return (0, uniqueArray_1.uniqueArray)((0, tuple_1.tuple)(ka, va), {
+ maxLength: maxKeys,
+ size,
+ comparator: 'SameValueZero',
+ selector: (t) => t[0],
+ depthIdentifier,
+ }).map(ArrayToMap_1.arrayToMapMapper, ArrayToMap_1.arrayToMapUnmapper);
+}
+function dictOf(ka, va, maxKeys, size, depthIdentifier, withNullPrototype) {
+ return (0, dictionary_1.dictionary)(ka, va, {
+ maxKeys,
+ noNullPrototype: !withNullPrototype,
+ size,
+ depthIdentifier,
+ });
+}
+function setOf(va, maxKeys, size, depthIdentifier) {
+ return (0, uniqueArray_1.uniqueArray)(va, { maxLength: maxKeys, size, comparator: 'SameValueZero', depthIdentifier }).map(ArrayToSet_1.arrayToSetMapper, ArrayToSet_1.arrayToSetUnmapper);
+}
+function typedArray(constraints) {
+ return (0, oneof_1.oneof)((0, int8Array_1.int8Array)(constraints), (0, uint8Array_1.uint8Array)(constraints), (0, uint8ClampedArray_1.uint8ClampedArray)(constraints), (0, int16Array_1.int16Array)(constraints), (0, uint16Array_1.uint16Array)(constraints), (0, int32Array_1.int32Array)(constraints), (0, uint32Array_1.uint32Array)(constraints), (0, float32Array_1.float32Array)(constraints), (0, float64Array_1.float64Array)(constraints));
+}
+function anyArbitraryBuilder(constraints) {
+ const arbitrariesForBase = constraints.values;
+ const depthSize = constraints.depthSize;
+ const depthIdentifier = (0, DepthContext_1.createDepthIdentifier)();
+ const maxDepth = constraints.maxDepth;
+ const maxKeys = constraints.maxKeys;
+ const size = constraints.size;
+ const baseArb = (0, oneof_1.oneof)(...arbitrariesForBase, ...(constraints.withBigInt ? [(0, bigInt_1.bigInt)()] : []), ...(constraints.withDate ? [(0, date_1.date)()] : []));
+ return (0, letrec_1.letrec)((tie) => ({
+ anything: (0, oneof_1.oneof)({ maxDepth, depthSize, depthIdentifier }, baseArb, tie('array'), tie('object'), ...(constraints.withMap ? [tie('map')] : []), ...(constraints.withSet ? [tie('set')] : []), ...(constraints.withObjectString ? [tie('anything').map((o) => (0, stringify_1.stringify)(o))] : []), ...(constraints.withTypedArray ? [typedArray({ maxLength: maxKeys, size })] : []), ...(constraints.withSparseArray
+ ? [(0, sparseArray_1.sparseArray)(tie('anything'), { maxNumElements: maxKeys, size, depthIdentifier })]
+ : [])),
+ keys: constraints.withObjectString
+ ? (0, oneof_1.oneof)({ arbitrary: constraints.key, weight: 10 }, { arbitrary: tie('anything').map((o) => (0, stringify_1.stringify)(o)), weight: 1 })
+ : constraints.key,
+ array: (0, array_1.array)(tie('anything'), { maxLength: maxKeys, size, depthIdentifier }),
+ set: setOf(tie('anything'), maxKeys, size, depthIdentifier),
+ map: (0, oneof_1.oneof)(mapOf(tie('keys'), tie('anything'), maxKeys, size, depthIdentifier), mapOf(tie('anything'), tie('anything'), maxKeys, size, depthIdentifier)),
+ object: dictOf(tie('keys'), tie('anything'), maxKeys, size, depthIdentifier, constraints.withNullPrototype),
+ })).anything;
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/builders/BoxedArbitraryBuilder.js b/node_modules/fast-check/lib/arbitrary/_internals/builders/BoxedArbitraryBuilder.js
new file mode 100644
index 0000000000000000000000000000000000000000..c67577088c26425168ba98c1cb3424318c0916a0
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/builders/BoxedArbitraryBuilder.js
@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.boxedArbitraryBuilder = boxedArbitraryBuilder;
+const UnboxedToBoxed_1 = require("../mappers/UnboxedToBoxed");
+function boxedArbitraryBuilder(arb) {
+ return arb.map(UnboxedToBoxed_1.unboxedToBoxedMapper, UnboxedToBoxed_1.unboxedToBoxedUnmapper);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/builders/CharacterArbitraryBuilder.js b/node_modules/fast-check/lib/arbitrary/_internals/builders/CharacterArbitraryBuilder.js
new file mode 100644
index 0000000000000000000000000000000000000000..793730e19fe08721a6b27341574a820db5eb7675
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/builders/CharacterArbitraryBuilder.js
@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCharacterArbitrary = buildCharacterArbitrary;
+const integer_1 = require("../../integer");
+const IndexToCharString_1 = require("../mappers/IndexToCharString");
+function buildCharacterArbitrary(min, max, mapToCode, unmapFromCode) {
+ return (0, integer_1.integer)({ min, max }).map((n) => (0, IndexToCharString_1.indexToCharStringMapper)(mapToCode(n)), (c) => unmapFromCode((0, IndexToCharString_1.indexToCharStringUnmapper)(c)));
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/builders/CharacterRangeArbitraryBuilder.js b/node_modules/fast-check/lib/arbitrary/_internals/builders/CharacterRangeArbitraryBuilder.js
new file mode 100644
index 0000000000000000000000000000000000000000..d88506a425e44ce81198f6a92db41123d1c552fb
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/builders/CharacterRangeArbitraryBuilder.js
@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOrCreateLowerAlphaArbitrary = getOrCreateLowerAlphaArbitrary;
+exports.getOrCreateLowerAlphaNumericArbitrary = getOrCreateLowerAlphaNumericArbitrary;
+exports.getOrCreateAlphaNumericPercentArbitrary = getOrCreateAlphaNumericPercentArbitrary;
+const fullUnicode_1 = require("../../fullUnicode");
+const oneof_1 = require("../../oneof");
+const mapToConstant_1 = require("../../mapToConstant");
+const globals_1 = require("../../../utils/globals");
+const SMap = Map;
+const safeStringFromCharCode = String.fromCharCode;
+const lowerCaseMapper = { num: 26, build: (v) => safeStringFromCharCode(v + 0x61) };
+const upperCaseMapper = { num: 26, build: (v) => safeStringFromCharCode(v + 0x41) };
+const numericMapper = { num: 10, build: (v) => safeStringFromCharCode(v + 0x30) };
+function percentCharArbMapper(c) {
+ const encoded = (0, globals_1.encodeURIComponent)(c);
+ return c !== encoded ? encoded : `%${(0, globals_1.safeNumberToString)((0, globals_1.safeCharCodeAt)(c, 0), 16)}`;
+}
+function percentCharArbUnmapper(value) {
+ if (typeof value !== 'string') {
+ throw new Error('Unsupported');
+ }
+ const decoded = decodeURIComponent(value);
+ return decoded;
+}
+const percentCharArb = (0, fullUnicode_1.fullUnicode)().map(percentCharArbMapper, percentCharArbUnmapper);
+let lowerAlphaArbitrary = undefined;
+function getOrCreateLowerAlphaArbitrary() {
+ if (lowerAlphaArbitrary === undefined) {
+ lowerAlphaArbitrary = (0, mapToConstant_1.mapToConstant)(lowerCaseMapper);
+ }
+ return lowerAlphaArbitrary;
+}
+let lowerAlphaNumericArbitraries = undefined;
+function getOrCreateLowerAlphaNumericArbitrary(others) {
+ if (lowerAlphaNumericArbitraries === undefined) {
+ lowerAlphaNumericArbitraries = new SMap();
+ }
+ let match = (0, globals_1.safeMapGet)(lowerAlphaNumericArbitraries, others);
+ if (match === undefined) {
+ match = (0, mapToConstant_1.mapToConstant)(lowerCaseMapper, numericMapper, {
+ num: others.length,
+ build: (v) => others[v],
+ });
+ (0, globals_1.safeMapSet)(lowerAlphaNumericArbitraries, others, match);
+ }
+ return match;
+}
+function buildAlphaNumericArbitrary(others) {
+ return (0, mapToConstant_1.mapToConstant)(lowerCaseMapper, upperCaseMapper, numericMapper, {
+ num: others.length,
+ build: (v) => others[v],
+ });
+}
+let alphaNumericPercentArbitraries = undefined;
+function getOrCreateAlphaNumericPercentArbitrary(others) {
+ if (alphaNumericPercentArbitraries === undefined) {
+ alphaNumericPercentArbitraries = new SMap();
+ }
+ let match = (0, globals_1.safeMapGet)(alphaNumericPercentArbitraries, others);
+ if (match === undefined) {
+ match = (0, oneof_1.oneof)({ weight: 10, arbitrary: buildAlphaNumericArbitrary(others) }, { weight: 1, arbitrary: percentCharArb });
+ (0, globals_1.safeMapSet)(alphaNumericPercentArbitraries, others, match);
+ }
+ return match;
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/builders/CompareFunctionArbitraryBuilder.js b/node_modules/fast-check/lib/arbitrary/_internals/builders/CompareFunctionArbitraryBuilder.js
new file mode 100644
index 0000000000000000000000000000000000000000..de6ec4041034661a08bf39fc144e37baebc250a2
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/builders/CompareFunctionArbitraryBuilder.js
@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCompareFunctionArbitrary = buildCompareFunctionArbitrary;
+const TextEscaper_1 = require("../helpers/TextEscaper");
+const symbols_1 = require("../../../check/symbols");
+const hash_1 = require("../../../utils/hash");
+const stringify_1 = require("../../../utils/stringify");
+const integer_1 = require("../../integer");
+const noShrink_1 = require("../../noShrink");
+const tuple_1 = require("../../tuple");
+const globals_1 = require("../../../utils/globals");
+const safeObjectAssign = Object.assign;
+const safeObjectKeys = Object.keys;
+function buildCompareFunctionArbitrary(cmp) {
+ return (0, tuple_1.tuple)((0, noShrink_1.noShrink)((0, integer_1.integer)()), (0, noShrink_1.noShrink)((0, integer_1.integer)({ min: 1, max: 0xffffffff }))).map(([seed, hashEnvSize]) => {
+ const producer = () => {
+ const recorded = {};
+ const f = (a, b) => {
+ const reprA = (0, stringify_1.stringify)(a);
+ const reprB = (0, stringify_1.stringify)(b);
+ const hA = (0, hash_1.hash)(`${seed}${reprA}`) % hashEnvSize;
+ const hB = (0, hash_1.hash)(`${seed}${reprB}`) % hashEnvSize;
+ const val = cmp(hA, hB);
+ recorded[`[${reprA},${reprB}]`] = val;
+ return val;
+ };
+ return safeObjectAssign(f, {
+ toString: () => {
+ const seenValues = safeObjectKeys(recorded)
+ .sort()
+ .map((k) => `${k} => ${(0, stringify_1.stringify)(recorded[k])}`)
+ .map((line) => `/* ${(0, TextEscaper_1.escapeForMultilineComments)(line)} */`);
+ return `function(a, b) {
+ // With hash and stringify coming from fast-check${seenValues.length !== 0 ? `\n ${(0, globals_1.safeJoin)(seenValues, '\n ')}` : ''}
+ const cmp = ${cmp};
+ const hA = hash('${seed}' + stringify(a)) % ${hashEnvSize};
+ const hB = hash('${seed}' + stringify(b)) % ${hashEnvSize};
+ return cmp(hA, hB);
+}`;
+ },
+ [symbols_1.cloneMethod]: producer,
+ });
+ };
+ return producer();
+ });
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/builders/GeneratorValueBuilder.js b/node_modules/fast-check/lib/arbitrary/_internals/builders/GeneratorValueBuilder.js
new file mode 100644
index 0000000000000000000000000000000000000000..65bded74a6fc2e84cb5ac4dc85bd43da903bf3f3
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/builders/GeneratorValueBuilder.js
@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildGeneratorValue = buildGeneratorValue;
+const Value_1 = require("../../../check/arbitrary/definition/Value");
+const symbols_1 = require("../../../check/symbols");
+const globals_1 = require("../../../utils/globals");
+const stringify_1 = require("../../../utils/stringify");
+const safeObjectAssign = Object.assign;
+function buildGeneratorValue(mrng, biasFactor, computePreBuiltValues, arbitraryCache) {
+ const preBuiltValues = computePreBuiltValues();
+ let localMrng = mrng.clone();
+ const context = { mrng: mrng.clone(), biasFactor, history: [] };
+ const valueFunction = (arb) => {
+ const preBuiltValue = preBuiltValues[context.history.length];
+ if (preBuiltValue !== undefined && preBuiltValue.arb === arb) {
+ const value = preBuiltValue.value;
+ (0, globals_1.safePush)(context.history, { arb, value, context: preBuiltValue.context, mrng: preBuiltValue.mrng });
+ localMrng = preBuiltValue.mrng.clone();
+ return value;
+ }
+ const g = arb.generate(localMrng, biasFactor);
+ (0, globals_1.safePush)(context.history, { arb, value: g.value_, context: g.context, mrng: localMrng.clone() });
+ return g.value;
+ };
+ const memoedValueFunction = (arb, ...args) => {
+ return valueFunction(arbitraryCache(arb, args));
+ };
+ const valueMethods = {
+ values() {
+ return (0, globals_1.safeMap)(context.history, (c) => c.value);
+ },
+ [symbols_1.cloneMethod]() {
+ return buildGeneratorValue(mrng, biasFactor, computePreBuiltValues, arbitraryCache).value;
+ },
+ [stringify_1.toStringMethod]() {
+ return (0, stringify_1.stringify)((0, globals_1.safeMap)(context.history, (c) => c.value));
+ },
+ };
+ const value = safeObjectAssign(memoedValueFunction, valueMethods);
+ return new Value_1.Value(value, context);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/builders/PaddedNumberArbitraryBuilder.js b/node_modules/fast-check/lib/arbitrary/_internals/builders/PaddedNumberArbitraryBuilder.js
new file mode 100644
index 0000000000000000000000000000000000000000..ee7c89c25029277fdd6fc29e87a5662051b1eeb6
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/builders/PaddedNumberArbitraryBuilder.js
@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildPaddedNumberArbitrary = buildPaddedNumberArbitrary;
+const integer_1 = require("../../integer");
+const NumberToPaddedEight_1 = require("../mappers/NumberToPaddedEight");
+function buildPaddedNumberArbitrary(min, max) {
+ return (0, integer_1.integer)({ min, max }).map(NumberToPaddedEight_1.numberToPaddedEightMapper, NumberToPaddedEight_1.numberToPaddedEightUnmapper);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/builders/PartialRecordArbitraryBuilder.js b/node_modules/fast-check/lib/arbitrary/_internals/builders/PartialRecordArbitraryBuilder.js
new file mode 100644
index 0000000000000000000000000000000000000000..a272f879349b6e3f5a2dd27a23c3ff13590358b6
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/builders/PartialRecordArbitraryBuilder.js
@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildPartialRecordArbitrary = buildPartialRecordArbitrary;
+const globals_1 = require("../../../utils/globals");
+const boolean_1 = require("../../boolean");
+const constant_1 = require("../../constant");
+const option_1 = require("../../option");
+const tuple_1 = require("../../tuple");
+const EnumerableKeysExtractor_1 = require("../helpers/EnumerableKeysExtractor");
+const ValuesAndSeparateKeysToObject_1 = require("../mappers/ValuesAndSeparateKeysToObject");
+const noKeyValue = Symbol('no-key');
+function buildPartialRecordArbitrary(recordModel, requiredKeys, noNullPrototype) {
+ const keys = (0, EnumerableKeysExtractor_1.extractEnumerableKeys)(recordModel);
+ const arbs = [];
+ for (let index = 0; index !== keys.length; ++index) {
+ const k = keys[index];
+ const requiredArbitrary = recordModel[k];
+ if (requiredKeys === undefined || (0, globals_1.safeIndexOf)(requiredKeys, k) !== -1) {
+ (0, globals_1.safePush)(arbs, requiredArbitrary);
+ }
+ else {
+ (0, globals_1.safePush)(arbs, (0, option_1.option)(requiredArbitrary, { nil: noKeyValue }));
+ }
+ }
+ return (0, tuple_1.tuple)((0, tuple_1.tuple)(...arbs), noNullPrototype ? (0, constant_1.constant)(false) : (0, boolean_1.boolean)()).map((0, ValuesAndSeparateKeysToObject_1.buildValuesAndSeparateKeysToObjectMapper)(keys, noKeyValue), (0, ValuesAndSeparateKeysToObject_1.buildValuesAndSeparateKeysToObjectUnmapper)(keys, noKeyValue));
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/builders/RestrictedIntegerArbitraryBuilder.js b/node_modules/fast-check/lib/arbitrary/_internals/builders/RestrictedIntegerArbitraryBuilder.js
new file mode 100644
index 0000000000000000000000000000000000000000..f88892a770aab93ce62810d5bf9dee82b3d1af1a
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/builders/RestrictedIntegerArbitraryBuilder.js
@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.restrictedIntegerArbitraryBuilder = restrictedIntegerArbitraryBuilder;
+const integer_1 = require("../../integer");
+const WithShrinkFromOtherArbitrary_1 = require("../WithShrinkFromOtherArbitrary");
+function restrictedIntegerArbitraryBuilder(min, maxGenerated, max) {
+ const generatorArbitrary = (0, integer_1.integer)({ min, max: maxGenerated });
+ if (maxGenerated === max) {
+ return generatorArbitrary;
+ }
+ const shrinkerArbitrary = (0, integer_1.integer)({ min, max });
+ return new WithShrinkFromOtherArbitrary_1.WithShrinkFromOtherArbitrary(generatorArbitrary, shrinkerArbitrary);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/builders/StableArbitraryGeneratorCache.js b/node_modules/fast-check/lib/arbitrary/_internals/builders/StableArbitraryGeneratorCache.js
new file mode 100644
index 0000000000000000000000000000000000000000..b0c761ada02051b1c816b472efb024f124d4f745
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/builders/StableArbitraryGeneratorCache.js
@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildStableArbitraryGeneratorCache = buildStableArbitraryGeneratorCache;
+exports.naiveIsEqual = naiveIsEqual;
+const globals_1 = require("../../../utils/globals");
+const safeArrayIsArray = Array.isArray;
+const safeObjectKeys = Object.keys;
+const safeObjectIs = Object.is;
+function buildStableArbitraryGeneratorCache(isEqual) {
+ const previousCallsPerBuilder = new globals_1.Map();
+ return function stableArbitraryGeneratorCache(builder, args) {
+ const entriesForBuilder = (0, globals_1.safeMapGet)(previousCallsPerBuilder, builder);
+ if (entriesForBuilder === undefined) {
+ const newValue = builder(...args);
+ (0, globals_1.safeMapSet)(previousCallsPerBuilder, builder, [{ args, value: newValue }]);
+ return newValue;
+ }
+ const safeEntriesForBuilder = entriesForBuilder;
+ for (const entry of safeEntriesForBuilder) {
+ if (isEqual(args, entry.args)) {
+ return entry.value;
+ }
+ }
+ const newValue = builder(...args);
+ (0, globals_1.safePush)(safeEntriesForBuilder, { args, value: newValue });
+ return newValue;
+ };
+}
+function naiveIsEqual(v1, v2) {
+ if (v1 !== null && typeof v1 === 'object' && v2 !== null && typeof v2 === 'object') {
+ if (safeArrayIsArray(v1)) {
+ if (!safeArrayIsArray(v2))
+ return false;
+ if (v1.length !== v2.length)
+ return false;
+ }
+ else if (safeArrayIsArray(v2)) {
+ return false;
+ }
+ if (safeObjectKeys(v1).length !== safeObjectKeys(v2).length) {
+ return false;
+ }
+ for (const index in v1) {
+ if (!(index in v2)) {
+ return false;
+ }
+ if (!naiveIsEqual(v1[index], v2[index])) {
+ return false;
+ }
+ }
+ return true;
+ }
+ else {
+ return safeObjectIs(v1, v2);
+ }
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/builders/StringifiedNatArbitraryBuilder.js b/node_modules/fast-check/lib/arbitrary/_internals/builders/StringifiedNatArbitraryBuilder.js
new file mode 100644
index 0000000000000000000000000000000000000000..db8b2f2ed44fee4cad8ba6f5ac4763467c44adc5
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/builders/StringifiedNatArbitraryBuilder.js
@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildStringifiedNatArbitrary = buildStringifiedNatArbitrary;
+const constantFrom_1 = require("../../constantFrom");
+const nat_1 = require("../../nat");
+const tuple_1 = require("../../tuple");
+const NatToStringifiedNat_1 = require("../mappers/NatToStringifiedNat");
+function buildStringifiedNatArbitrary(maxValue) {
+ return (0, tuple_1.tuple)((0, constantFrom_1.constantFrom)('dec', 'oct', 'hex'), (0, nat_1.nat)(maxValue)).map(NatToStringifiedNat_1.natToStringifiedNatMapper, NatToStringifiedNat_1.natToStringifiedNatUnmapper);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/builders/TypedIntArrayArbitraryBuilder.js b/node_modules/fast-check/lib/arbitrary/_internals/builders/TypedIntArrayArbitraryBuilder.js
new file mode 100644
index 0000000000000000000000000000000000000000..ac5b36ee73a9c93e41799e2397272bd7be78a5d5
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/builders/TypedIntArrayArbitraryBuilder.js
@@ -0,0 +1,33 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+ var t = {};
+ for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+ t[p] = s[p];
+ if (s != null && typeof Object.getOwnPropertySymbols === "function")
+ for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+ if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+ t[p[i]] = s[p[i]];
+ }
+ return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typedIntArrayArbitraryArbitraryBuilder = typedIntArrayArbitraryArbitraryBuilder;
+const array_1 = require("../../array");
+function typedIntArrayArbitraryArbitraryBuilder(constraints, defaultMin, defaultMax, TypedArrayClass, arbitraryBuilder) {
+ const generatorName = TypedArrayClass.name;
+ const { min = defaultMin, max = defaultMax } = constraints, arrayConstraints = __rest(constraints, ["min", "max"]);
+ if (min > max) {
+ throw new Error(`Invalid range passed to ${generatorName}: min must be lower than or equal to max`);
+ }
+ if (min < defaultMin) {
+ throw new Error(`Invalid min value passed to ${generatorName}: min must be greater than or equal to ${defaultMin}`);
+ }
+ if (max > defaultMax) {
+ throw new Error(`Invalid max value passed to ${generatorName}: max must be lower than or equal to ${defaultMax}`);
+ }
+ return (0, array_1.array)(arbitraryBuilder({ min, max }), arrayConstraints).map((data) => TypedArrayClass.from(data), (value) => {
+ if (!(value instanceof TypedArrayClass))
+ throw new Error('Invalid type');
+ return [...value];
+ });
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/builders/UriPathArbitraryBuilder.js b/node_modules/fast-check/lib/arbitrary/_internals/builders/UriPathArbitraryBuilder.js
new file mode 100644
index 0000000000000000000000000000000000000000..3356346c205cdd990dd6a9737ae0817885641ff1
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/builders/UriPathArbitraryBuilder.js
@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildUriPathArbitrary = buildUriPathArbitrary;
+const webSegment_1 = require("../../webSegment");
+const array_1 = require("../../array");
+const SegmentsToPath_1 = require("../mappers/SegmentsToPath");
+const oneof_1 = require("../../oneof");
+function sqrtSize(size) {
+ switch (size) {
+ case 'xsmall':
+ return ['xsmall', 'xsmall'];
+ case 'small':
+ return ['small', 'xsmall'];
+ case 'medium':
+ return ['small', 'small'];
+ case 'large':
+ return ['medium', 'small'];
+ case 'xlarge':
+ return ['medium', 'medium'];
+ }
+}
+function buildUriPathArbitraryInternal(segmentSize, numSegmentSize) {
+ return (0, array_1.array)((0, webSegment_1.webSegment)({ size: segmentSize }), { size: numSegmentSize }).map(SegmentsToPath_1.segmentsToPathMapper, SegmentsToPath_1.segmentsToPathUnmapper);
+}
+function buildUriPathArbitrary(resolvedSize) {
+ const [segmentSize, numSegmentSize] = sqrtSize(resolvedSize);
+ if (segmentSize === numSegmentSize) {
+ return buildUriPathArbitraryInternal(segmentSize, numSegmentSize);
+ }
+ return (0, oneof_1.oneof)(buildUriPathArbitraryInternal(segmentSize, numSegmentSize), buildUriPathArbitraryInternal(numSegmentSize, segmentSize));
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/builders/UriQueryOrFragmentArbitraryBuilder.js b/node_modules/fast-check/lib/arbitrary/_internals/builders/UriQueryOrFragmentArbitraryBuilder.js
new file mode 100644
index 0000000000000000000000000000000000000000..994b4ce0d15da427842094fca78199ac76013602
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/builders/UriQueryOrFragmentArbitraryBuilder.js
@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildUriQueryOrFragmentArbitrary = buildUriQueryOrFragmentArbitrary;
+const CharacterRangeArbitraryBuilder_1 = require("./CharacterRangeArbitraryBuilder");
+const string_1 = require("../../string");
+function buildUriQueryOrFragmentArbitrary(size) {
+ return (0, string_1.string)({ unit: (0, CharacterRangeArbitraryBuilder_1.getOrCreateAlphaNumericPercentArbitrary)("-._~!$&'()*+,;=:@/?"), size });
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/data/GraphemeRanges.js b/node_modules/fast-check/lib/arbitrary/_internals/data/GraphemeRanges.js
new file mode 100644
index 0000000000000000000000000000000000000000..cacd848013185b9a0300343c0ebbddcd2e544fa8
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/data/GraphemeRanges.js
@@ -0,0 +1,988 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.autonomousDecomposableGraphemeRanges = exports.autonomousGraphemeRanges = exports.fullAlphabetRanges = exports.asciiAlphabetRanges = void 0;
+exports.asciiAlphabetRanges = [[0x00, 0x7f]];
+exports.fullAlphabetRanges = [
+ [0x0000, 0xd7ff],
+ [0xe000, 0x10ffff],
+];
+exports.autonomousGraphemeRanges = [
+ [0x20, 0x7e],
+ [0xa0, 0xac],
+ [0xae, 0x2ff],
+ [0x370, 0x377],
+ [0x37a, 0x37f],
+ [0x384, 0x38a],
+ [0x38c],
+ [0x38e, 0x3a1],
+ [0x3a3, 0x482],
+ [0x48a, 0x52f],
+ [0x531, 0x556],
+ [0x559, 0x58a],
+ [0x58d, 0x58f],
+ [0x5be],
+ [0x5c0],
+ [0x5c3],
+ [0x5c6],
+ [0x5d0, 0x5ea],
+ [0x5ef, 0x5f4],
+ [0x606, 0x60f],
+ [0x61b],
+ [0x61d, 0x64a],
+ [0x660, 0x66f],
+ [0x671, 0x6d5],
+ [0x6de],
+ [0x6e5, 0x6e6],
+ [0x6e9],
+ [0x6ee, 0x70d],
+ [0x710],
+ [0x712, 0x72f],
+ [0x74d, 0x7a5],
+ [0x7b1],
+ [0x7c0, 0x7ea],
+ [0x7f4, 0x7fa],
+ [0x7fe, 0x815],
+ [0x81a],
+ [0x824],
+ [0x828],
+ [0x830, 0x83e],
+ [0x840, 0x858],
+ [0x85e],
+ [0x860, 0x86a],
+ [0x870, 0x88e],
+ [0x8a0, 0x8c9],
+ [0x904, 0x939],
+ [0x93d],
+ [0x950],
+ [0x958, 0x961],
+ [0x964, 0x980],
+ [0x985, 0x98c],
+ [0x98f, 0x990],
+ [0x993, 0x9a8],
+ [0x9aa, 0x9b0],
+ [0x9b2],
+ [0x9b6, 0x9b9],
+ [0x9bd],
+ [0x9ce],
+ [0x9dc, 0x9dd],
+ [0x9df, 0x9e1],
+ [0x9e6, 0x9fd],
+ [0xa05, 0xa0a],
+ [0xa0f, 0xa10],
+ [0xa13, 0xa28],
+ [0xa2a, 0xa30],
+ [0xa32, 0xa33],
+ [0xa35, 0xa36],
+ [0xa38, 0xa39],
+ [0xa59, 0xa5c],
+ [0xa5e],
+ [0xa66, 0xa6f],
+ [0xa72, 0xa74],
+ [0xa76],
+ [0xa85, 0xa8d],
+ [0xa8f, 0xa91],
+ [0xa93, 0xaa8],
+ [0xaaa, 0xab0],
+ [0xab2, 0xab3],
+ [0xab5, 0xab9],
+ [0xabd],
+ [0xad0],
+ [0xae0, 0xae1],
+ [0xae6, 0xaf1],
+ [0xaf9],
+ [0xb05, 0xb0c],
+ [0xb0f, 0xb10],
+ [0xb13, 0xb28],
+ [0xb2a, 0xb30],
+ [0xb32, 0xb33],
+ [0xb35, 0xb39],
+ [0xb3d],
+ [0xb5c, 0xb5d],
+ [0xb5f, 0xb61],
+ [0xb66, 0xb77],
+ [0xb83],
+ [0xb85, 0xb8a],
+ [0xb8e, 0xb90],
+ [0xb92, 0xb95],
+ [0xb99, 0xb9a],
+ [0xb9c],
+ [0xb9e, 0xb9f],
+ [0xba3, 0xba4],
+ [0xba8, 0xbaa],
+ [0xbae, 0xbb9],
+ [0xbd0],
+ [0xbe6, 0xbfa],
+ [0xc05, 0xc0c],
+ [0xc0e, 0xc10],
+ [0xc12, 0xc28],
+ [0xc2a, 0xc39],
+ [0xc3d],
+ [0xc58, 0xc5a],
+ [0xc5d],
+ [0xc60, 0xc61],
+ [0xc66, 0xc6f],
+ [0xc77, 0xc80],
+ [0xc84, 0xc8c],
+ [0xc8e, 0xc90],
+ [0xc92, 0xca8],
+ [0xcaa, 0xcb3],
+ [0xcb5, 0xcb9],
+ [0xcbd],
+ [0xcdd, 0xcde],
+ [0xce0, 0xce1],
+ [0xce6, 0xcef],
+ [0xcf1, 0xcf2],
+ [0xd04, 0xd0c],
+ [0xd0e, 0xd10],
+ [0xd12, 0xd3a],
+ [0xd3d],
+ [0xd4f],
+ [0xd54, 0xd56],
+ [0xd58, 0xd61],
+ [0xd66, 0xd7f],
+ [0xd85, 0xd96],
+ [0xd9a, 0xdb1],
+ [0xdb3, 0xdbb],
+ [0xdbd],
+ [0xdc0, 0xdc6],
+ [0xde6, 0xdef],
+ [0xdf4],
+ [0xe01, 0xe30],
+ [0xe32],
+ [0xe3f, 0xe46],
+ [0xe4f, 0xe5b],
+ [0xe81, 0xe82],
+ [0xe84],
+ [0xe86, 0xe8a],
+ [0xe8c, 0xea3],
+ [0xea5],
+ [0xea7, 0xeb0],
+ [0xeb2],
+ [0xebd],
+ [0xec0, 0xec4],
+ [0xec6],
+ [0xed0, 0xed9],
+ [0xedc, 0xedf],
+ [0xf00, 0xf17],
+ [0xf1a, 0xf34],
+ [0xf36],
+ [0xf38],
+ [0xf3a, 0xf3d],
+ [0xf40, 0xf47],
+ [0xf49, 0xf6c],
+ [0xf85],
+ [0xf88, 0xf8c],
+ [0xfbe, 0xfc5],
+ [0xfc7, 0xfcc],
+ [0xfce, 0xfda],
+ [0x1000, 0x102a],
+ [0x103f, 0x1055],
+ [0x105a, 0x105d],
+ [0x1061],
+ [0x1065, 0x1066],
+ [0x106e, 0x1070],
+ [0x1075, 0x1081],
+ [0x108e],
+ [0x1090, 0x1099],
+ [0x109e, 0x10c5],
+ [0x10c7],
+ [0x10cd],
+ [0x10d0, 0x10ff],
+ [0x1200, 0x1248],
+ [0x124a, 0x124d],
+ [0x1250, 0x1256],
+ [0x1258],
+ [0x125a, 0x125d],
+ [0x1260, 0x1288],
+ [0x128a, 0x128d],
+ [0x1290, 0x12b0],
+ [0x12b2, 0x12b5],
+ [0x12b8, 0x12be],
+ [0x12c0],
+ [0x12c2, 0x12c5],
+ [0x12c8, 0x12d6],
+ [0x12d8, 0x1310],
+ [0x1312, 0x1315],
+ [0x1318, 0x135a],
+ [0x1360, 0x137c],
+ [0x1380, 0x1399],
+ [0x13a0, 0x13f5],
+ [0x13f8, 0x13fd],
+ [0x1400, 0x169c],
+ [0x16a0, 0x16f8],
+ [0x1700, 0x1711],
+ [0x171f, 0x1731],
+ [0x1735, 0x1736],
+ [0x1740, 0x1751],
+ [0x1760, 0x176c],
+ [0x176e, 0x1770],
+ [0x1780, 0x17b3],
+ [0x17d4, 0x17dc],
+ [0x17e0, 0x17e9],
+ [0x17f0, 0x17f9],
+ [0x1800, 0x180a],
+ [0x1810, 0x1819],
+ [0x1820, 0x1878],
+ [0x1880, 0x1884],
+ [0x1887, 0x18a8],
+ [0x18aa],
+ [0x18b0, 0x18f5],
+ [0x1900, 0x191e],
+ [0x1940],
+ [0x1944, 0x196d],
+ [0x1970, 0x1974],
+ [0x1980, 0x19ab],
+ [0x19b0, 0x19c9],
+ [0x19d0, 0x19da],
+ [0x19de, 0x1a16],
+ [0x1a1e, 0x1a54],
+ [0x1a80, 0x1a89],
+ [0x1a90, 0x1a99],
+ [0x1aa0, 0x1aad],
+ [0x1b05, 0x1b33],
+ [0x1b45, 0x1b4c],
+ [0x1b50, 0x1b6a],
+ [0x1b74, 0x1b7e],
+ [0x1b83, 0x1ba0],
+ [0x1bae, 0x1be5],
+ [0x1bfc, 0x1c23],
+ [0x1c3b, 0x1c49],
+ [0x1c4d, 0x1c88],
+ [0x1c90, 0x1cba],
+ [0x1cbd, 0x1cc7],
+ [0x1cd3],
+ [0x1ce9, 0x1cec],
+ [0x1cee, 0x1cf3],
+ [0x1cf5, 0x1cf6],
+ [0x1cfa],
+ [0x1d00, 0x1dbf],
+ [0x1e00, 0x1f15],
+ [0x1f18, 0x1f1d],
+ [0x1f20, 0x1f45],
+ [0x1f48, 0x1f4d],
+ [0x1f50, 0x1f57],
+ [0x1f59],
+ [0x1f5b],
+ [0x1f5d],
+ [0x1f5f, 0x1f7d],
+ [0x1f80, 0x1fb4],
+ [0x1fb6, 0x1fc4],
+ [0x1fc6, 0x1fd3],
+ [0x1fd6, 0x1fdb],
+ [0x1fdd, 0x1fef],
+ [0x1ff2, 0x1ff4],
+ [0x1ff6, 0x1ffe],
+ [0x2000, 0x200a],
+ [0x2010, 0x2029],
+ [0x202f, 0x205f],
+ [0x2070, 0x2071],
+ [0x2074, 0x208e],
+ [0x2090, 0x209c],
+ [0x20a0, 0x20c0],
+ [0x2100, 0x218b],
+ [0x2190, 0x2426],
+ [0x2440, 0x244a],
+ [0x2460, 0x2b73],
+ [0x2b76, 0x2b95],
+ [0x2b97, 0x2cee],
+ [0x2cf2, 0x2cf3],
+ [0x2cf9, 0x2d25],
+ [0x2d27],
+ [0x2d2d],
+ [0x2d30, 0x2d67],
+ [0x2d6f, 0x2d70],
+ [0x2d80, 0x2d96],
+ [0x2da0, 0x2da6],
+ [0x2da8, 0x2dae],
+ [0x2db0, 0x2db6],
+ [0x2db8, 0x2dbe],
+ [0x2dc0, 0x2dc6],
+ [0x2dc8, 0x2dce],
+ [0x2dd0, 0x2dd6],
+ [0x2dd8, 0x2dde],
+ [0x2e00, 0x2e5d],
+ [0x2e80, 0x2e99],
+ [0x2e9b, 0x2ef3],
+ [0x2f00, 0x2fd5],
+ [0x2ff0, 0x3029],
+ [0x3030, 0x303f],
+ [0x3041, 0x3096],
+ [0x309b, 0x30ff],
+ [0x3105, 0x312f],
+ [0x3131, 0x318e],
+ [0x3190, 0x31e3],
+ [0x31ef, 0x321e],
+ [0x3220, 0x3400],
+ [0x4dbf, 0x4e00],
+ [0x9fff, 0xa48c],
+ [0xa490, 0xa4c6],
+ [0xa4d0, 0xa62b],
+ [0xa640, 0xa66e],
+ [0xa673],
+ [0xa67e, 0xa69d],
+ [0xa6a0, 0xa6ef],
+ [0xa6f2, 0xa6f7],
+ [0xa700, 0xa7ca],
+ [0xa7d0, 0xa7d1],
+ [0xa7d3],
+ [0xa7d5, 0xa7d9],
+ [0xa7f2, 0xa801],
+ [0xa803, 0xa805],
+ [0xa807, 0xa80a],
+ [0xa80c, 0xa822],
+ [0xa828, 0xa82b],
+ [0xa830, 0xa839],
+ [0xa840, 0xa877],
+ [0xa882, 0xa8b3],
+ [0xa8ce, 0xa8d9],
+ [0xa8f2, 0xa8fe],
+ [0xa900, 0xa925],
+ [0xa92e, 0xa946],
+ [0xa95f],
+ [0xa984, 0xa9b2],
+ [0xa9c1, 0xa9cd],
+ [0xa9cf, 0xa9d9],
+ [0xa9de, 0xa9e4],
+ [0xa9e6, 0xa9fe],
+ [0xaa00, 0xaa28],
+ [0xaa40, 0xaa42],
+ [0xaa44, 0xaa4b],
+ [0xaa50, 0xaa59],
+ [0xaa5c, 0xaa7a],
+ [0xaa7e, 0xaaaf],
+ [0xaab1],
+ [0xaab5, 0xaab6],
+ [0xaab9, 0xaabd],
+ [0xaac0],
+ [0xaac2],
+ [0xaadb, 0xaaea],
+ [0xaaf0, 0xaaf4],
+ [0xab01, 0xab06],
+ [0xab09, 0xab0e],
+ [0xab11, 0xab16],
+ [0xab20, 0xab26],
+ [0xab28, 0xab2e],
+ [0xab30, 0xab6b],
+ [0xab70, 0xabe2],
+ [0xabeb],
+ [0xabf0, 0xabf9],
+ [0xac00],
+ [0xd7a3],
+ [0xf900, 0xfa6d],
+ [0xfa70, 0xfad9],
+ [0xfb00, 0xfb06],
+ [0xfb13, 0xfb17],
+ [0xfb1d],
+ [0xfb1f, 0xfb36],
+ [0xfb38, 0xfb3c],
+ [0xfb3e],
+ [0xfb40, 0xfb41],
+ [0xfb43, 0xfb44],
+ [0xfb46, 0xfbc2],
+ [0xfbd3, 0xfd8f],
+ [0xfd92, 0xfdc7],
+ [0xfdcf],
+ [0xfdf0, 0xfdff],
+ [0xfe10, 0xfe19],
+ [0xfe30, 0xfe52],
+ [0xfe54, 0xfe66],
+ [0xfe68, 0xfe6b],
+ [0xfe70, 0xfe74],
+ [0xfe76, 0xfefc],
+ [0xff01, 0xff9d],
+ [0xffa0, 0xffbe],
+ [0xffc2, 0xffc7],
+ [0xffca, 0xffcf],
+ [0xffd2, 0xffd7],
+ [0xffda, 0xffdc],
+ [0xffe0, 0xffe6],
+ [0xffe8, 0xffee],
+ [0xfffc, 0xfffd],
+ [0x10000, 0x1000b],
+ [0x1000d, 0x10026],
+ [0x10028, 0x1003a],
+ [0x1003c, 0x1003d],
+ [0x1003f, 0x1004d],
+ [0x10050, 0x1005d],
+ [0x10080, 0x100fa],
+ [0x10100, 0x10102],
+ [0x10107, 0x10133],
+ [0x10137, 0x1018e],
+ [0x10190, 0x1019c],
+ [0x101a0],
+ [0x101d0, 0x101fc],
+ [0x10280, 0x1029c],
+ [0x102a0, 0x102d0],
+ [0x102e1, 0x102fb],
+ [0x10300, 0x10323],
+ [0x1032d, 0x1034a],
+ [0x10350, 0x10375],
+ [0x10380, 0x1039d],
+ [0x1039f, 0x103c3],
+ [0x103c8, 0x103d5],
+ [0x10400, 0x1049d],
+ [0x104a0, 0x104a9],
+ [0x104b0, 0x104d3],
+ [0x104d8, 0x104fb],
+ [0x10500, 0x10527],
+ [0x10530, 0x10563],
+ [0x1056f, 0x1057a],
+ [0x1057c, 0x1058a],
+ [0x1058c, 0x10592],
+ [0x10594, 0x10595],
+ [0x10597, 0x105a1],
+ [0x105a3, 0x105b1],
+ [0x105b3, 0x105b9],
+ [0x105bb, 0x105bc],
+ [0x10600, 0x10736],
+ [0x10740, 0x10755],
+ [0x10760, 0x10767],
+ [0x10780, 0x10785],
+ [0x10787, 0x107b0],
+ [0x107b2, 0x107ba],
+ [0x10800, 0x10805],
+ [0x10808],
+ [0x1080a, 0x10835],
+ [0x10837, 0x10838],
+ [0x1083c],
+ [0x1083f, 0x10855],
+ [0x10857, 0x1089e],
+ [0x108a7, 0x108af],
+ [0x108e0, 0x108f2],
+ [0x108f4, 0x108f5],
+ [0x108fb, 0x1091b],
+ [0x1091f, 0x10939],
+ [0x1093f],
+ [0x10980, 0x109b7],
+ [0x109bc, 0x109cf],
+ [0x109d2, 0x10a00],
+ [0x10a10, 0x10a13],
+ [0x10a15, 0x10a17],
+ [0x10a19, 0x10a35],
+ [0x10a40, 0x10a48],
+ [0x10a50, 0x10a58],
+ [0x10a60, 0x10a9f],
+ [0x10ac0, 0x10ae4],
+ [0x10aeb, 0x10af6],
+ [0x10b00, 0x10b35],
+ [0x10b39, 0x10b55],
+ [0x10b58, 0x10b72],
+ [0x10b78, 0x10b91],
+ [0x10b99, 0x10b9c],
+ [0x10ba9, 0x10baf],
+ [0x10c00, 0x10c48],
+ [0x10c80, 0x10cb2],
+ [0x10cc0, 0x10cf2],
+ [0x10cfa, 0x10d23],
+ [0x10d30, 0x10d39],
+ [0x10e60, 0x10e7e],
+ [0x10e80, 0x10ea9],
+ [0x10ead],
+ [0x10eb0, 0x10eb1],
+ [0x10f00, 0x10f27],
+ [0x10f30, 0x10f45],
+ [0x10f51, 0x10f59],
+ [0x10f70, 0x10f81],
+ [0x10f86, 0x10f89],
+ [0x10fb0, 0x10fcb],
+ [0x10fe0, 0x10ff6],
+ [0x11003, 0x11037],
+ [0x11047, 0x1104d],
+ [0x11052, 0x1106f],
+ [0x11071, 0x11072],
+ [0x11075],
+ [0x11083, 0x110af],
+ [0x110bb, 0x110bc],
+ [0x110be, 0x110c1],
+ [0x110d0, 0x110e8],
+ [0x110f0, 0x110f9],
+ [0x11103, 0x11126],
+ [0x11136, 0x11144],
+ [0x11147],
+ [0x11150, 0x11172],
+ [0x11174, 0x11176],
+ [0x11183, 0x111b2],
+ [0x111c1],
+ [0x111c4, 0x111c8],
+ [0x111cd],
+ [0x111d0, 0x111df],
+ [0x111e1, 0x111f4],
+ [0x11200, 0x11211],
+ [0x11213, 0x1122b],
+ [0x11238, 0x1123d],
+ [0x1123f, 0x11240],
+ [0x11280, 0x11286],
+ [0x11288],
+ [0x1128a, 0x1128d],
+ [0x1128f, 0x1129d],
+ [0x1129f, 0x112a9],
+ [0x112b0, 0x112de],
+ [0x112f0, 0x112f9],
+ [0x11305, 0x1130c],
+ [0x1130f, 0x11310],
+ [0x11313, 0x11328],
+ [0x1132a, 0x11330],
+ [0x11332, 0x11333],
+ [0x11335, 0x11339],
+ [0x1133d],
+ [0x11350],
+ [0x1135d, 0x11361],
+ [0x11400, 0x11434],
+ [0x11447, 0x1145b],
+ [0x1145d],
+ [0x1145f, 0x11461],
+ [0x11480, 0x114af],
+ [0x114c4, 0x114c7],
+ [0x114d0, 0x114d9],
+ [0x11580, 0x115ae],
+ [0x115c1, 0x115db],
+ [0x11600, 0x1162f],
+ [0x11641, 0x11644],
+ [0x11650, 0x11659],
+ [0x11660, 0x1166c],
+ [0x11680, 0x116aa],
+ [0x116b8, 0x116b9],
+ [0x116c0, 0x116c9],
+ [0x11700, 0x1171a],
+ [0x11730, 0x11746],
+ [0x11800, 0x1182b],
+ [0x1183b],
+ [0x118a0, 0x118f2],
+ [0x118ff, 0x11906],
+ [0x11909],
+ [0x1190c, 0x11913],
+ [0x11915, 0x11916],
+ [0x11918, 0x1192f],
+ [0x11944, 0x11946],
+ [0x11950, 0x11959],
+ [0x119a0, 0x119a7],
+ [0x119aa, 0x119d0],
+ [0x119e1, 0x119e3],
+ [0x11a00],
+ [0x11a0b, 0x11a32],
+ [0x11a3f, 0x11a46],
+ [0x11a50],
+ [0x11a5c, 0x11a83],
+ [0x11a9a, 0x11aa2],
+ [0x11ab0, 0x11af8],
+ [0x11b00, 0x11b09],
+ [0x11c00, 0x11c08],
+ [0x11c0a, 0x11c2e],
+ [0x11c40, 0x11c45],
+ [0x11c50, 0x11c6c],
+ [0x11c70, 0x11c8f],
+ [0x11d00, 0x11d06],
+ [0x11d08, 0x11d09],
+ [0x11d0b, 0x11d30],
+ [0x11d50, 0x11d59],
+ [0x11d60, 0x11d65],
+ [0x11d67, 0x11d68],
+ [0x11d6a, 0x11d89],
+ [0x11d98],
+ [0x11da0, 0x11da9],
+ [0x11ee0, 0x11ef2],
+ [0x11ef7, 0x11ef8],
+ [0x11f04, 0x11f10],
+ [0x11f12, 0x11f33],
+ [0x11f43, 0x11f59],
+ [0x11fb0],
+ [0x11fc0, 0x11ff1],
+ [0x11fff, 0x12399],
+ [0x12400, 0x1246e],
+ [0x12470, 0x12474],
+ [0x12480, 0x12543],
+ [0x12f90, 0x12ff2],
+ [0x13000, 0x1342f],
+ [0x13441, 0x13446],
+ [0x14400, 0x14646],
+ [0x16800, 0x16a38],
+ [0x16a40, 0x16a5e],
+ [0x16a60, 0x16a69],
+ [0x16a6e, 0x16abe],
+ [0x16ac0, 0x16ac9],
+ [0x16ad0, 0x16aed],
+ [0x16af5],
+ [0x16b00, 0x16b2f],
+ [0x16b37, 0x16b45],
+ [0x16b50, 0x16b59],
+ [0x16b5b, 0x16b61],
+ [0x16b63, 0x16b77],
+ [0x16b7d, 0x16b8f],
+ [0x16e40, 0x16e9a],
+ [0x16f00, 0x16f4a],
+ [0x16f50],
+ [0x16f93, 0x16f9f],
+ [0x16fe0, 0x16fe3],
+ [0x17000],
+ [0x187f7],
+ [0x18800, 0x18cd5],
+ [0x18d00],
+ [0x18d08],
+ [0x1aff0, 0x1aff3],
+ [0x1aff5, 0x1affb],
+ [0x1affd, 0x1affe],
+ [0x1b000, 0x1b122],
+ [0x1b132],
+ [0x1b150, 0x1b152],
+ [0x1b155],
+ [0x1b164, 0x1b167],
+ [0x1b170, 0x1b2fb],
+ [0x1bc00, 0x1bc6a],
+ [0x1bc70, 0x1bc7c],
+ [0x1bc80, 0x1bc88],
+ [0x1bc90, 0x1bc99],
+ [0x1bc9c],
+ [0x1bc9f],
+ [0x1cf50, 0x1cfc3],
+ [0x1d000, 0x1d0f5],
+ [0x1d100, 0x1d126],
+ [0x1d129, 0x1d164],
+ [0x1d16a, 0x1d16c],
+ [0x1d183, 0x1d184],
+ [0x1d18c, 0x1d1a9],
+ [0x1d1ae, 0x1d1ea],
+ [0x1d200, 0x1d241],
+ [0x1d245],
+ [0x1d2c0, 0x1d2d3],
+ [0x1d2e0, 0x1d2f3],
+ [0x1d300, 0x1d356],
+ [0x1d360, 0x1d378],
+ [0x1d400, 0x1d454],
+ [0x1d456, 0x1d49c],
+ [0x1d49e, 0x1d49f],
+ [0x1d4a2],
+ [0x1d4a5, 0x1d4a6],
+ [0x1d4a9, 0x1d4ac],
+ [0x1d4ae, 0x1d4b9],
+ [0x1d4bb],
+ [0x1d4bd, 0x1d4c3],
+ [0x1d4c5, 0x1d505],
+ [0x1d507, 0x1d50a],
+ [0x1d50d, 0x1d514],
+ [0x1d516, 0x1d51c],
+ [0x1d51e, 0x1d539],
+ [0x1d53b, 0x1d53e],
+ [0x1d540, 0x1d544],
+ [0x1d546],
+ [0x1d54a, 0x1d550],
+ [0x1d552, 0x1d6a5],
+ [0x1d6a8, 0x1d7cb],
+ [0x1d7ce, 0x1d9ff],
+ [0x1da37, 0x1da3a],
+ [0x1da6d, 0x1da74],
+ [0x1da76, 0x1da83],
+ [0x1da85, 0x1da8b],
+ [0x1df00, 0x1df1e],
+ [0x1df25, 0x1df2a],
+ [0x1e030, 0x1e06d],
+ [0x1e100, 0x1e12c],
+ [0x1e137, 0x1e13d],
+ [0x1e140, 0x1e149],
+ [0x1e14e, 0x1e14f],
+ [0x1e290, 0x1e2ad],
+ [0x1e2c0, 0x1e2eb],
+ [0x1e2f0, 0x1e2f9],
+ [0x1e2ff],
+ [0x1e4d0, 0x1e4eb],
+ [0x1e4f0, 0x1e4f9],
+ [0x1e7e0, 0x1e7e6],
+ [0x1e7e8, 0x1e7eb],
+ [0x1e7ed, 0x1e7ee],
+ [0x1e7f0, 0x1e7fe],
+ [0x1e800, 0x1e8c4],
+ [0x1e8c7, 0x1e8cf],
+ [0x1e900, 0x1e943],
+ [0x1e94b],
+ [0x1e950, 0x1e959],
+ [0x1e95e, 0x1e95f],
+ [0x1ec71, 0x1ecb4],
+ [0x1ed01, 0x1ed3d],
+ [0x1ee00, 0x1ee03],
+ [0x1ee05, 0x1ee1f],
+ [0x1ee21, 0x1ee22],
+ [0x1ee24],
+ [0x1ee27],
+ [0x1ee29, 0x1ee32],
+ [0x1ee34, 0x1ee37],
+ [0x1ee39],
+ [0x1ee3b],
+ [0x1ee42],
+ [0x1ee47],
+ [0x1ee49],
+ [0x1ee4b],
+ [0x1ee4d, 0x1ee4f],
+ [0x1ee51, 0x1ee52],
+ [0x1ee54],
+ [0x1ee57],
+ [0x1ee59],
+ [0x1ee5b],
+ [0x1ee5d],
+ [0x1ee5f],
+ [0x1ee61, 0x1ee62],
+ [0x1ee64],
+ [0x1ee67, 0x1ee6a],
+ [0x1ee6c, 0x1ee72],
+ [0x1ee74, 0x1ee77],
+ [0x1ee79, 0x1ee7c],
+ [0x1ee7e],
+ [0x1ee80, 0x1ee89],
+ [0x1ee8b, 0x1ee9b],
+ [0x1eea1, 0x1eea3],
+ [0x1eea5, 0x1eea9],
+ [0x1eeab, 0x1eebb],
+ [0x1eef0, 0x1eef1],
+ [0x1f000, 0x1f02b],
+ [0x1f030, 0x1f093],
+ [0x1f0a0, 0x1f0ae],
+ [0x1f0b1, 0x1f0bf],
+ [0x1f0c1, 0x1f0cf],
+ [0x1f0d1, 0x1f0f5],
+ [0x1f100, 0x1f1ad],
+ [0x1f200, 0x1f202],
+ [0x1f210, 0x1f23b],
+ [0x1f240, 0x1f248],
+ [0x1f250, 0x1f251],
+ [0x1f260, 0x1f265],
+ [0x1f300, 0x1f3fa],
+ [0x1f400, 0x1f6d7],
+ [0x1f6dc, 0x1f6ec],
+ [0x1f6f0, 0x1f6fc],
+ [0x1f700, 0x1f776],
+ [0x1f77b, 0x1f7d9],
+ [0x1f7e0, 0x1f7eb],
+ [0x1f7f0],
+ [0x1f800, 0x1f80b],
+ [0x1f810, 0x1f847],
+ [0x1f850, 0x1f859],
+ [0x1f860, 0x1f887],
+ [0x1f890, 0x1f8ad],
+ [0x1f8b0, 0x1f8b1],
+ [0x1f900, 0x1fa53],
+ [0x1fa60, 0x1fa6d],
+ [0x1fa70, 0x1fa7c],
+ [0x1fa80, 0x1fa88],
+ [0x1fa90, 0x1fabd],
+ [0x1fabf, 0x1fac5],
+ [0x1face, 0x1fadb],
+ [0x1fae0, 0x1fae8],
+ [0x1faf0, 0x1faf8],
+ [0x1fb00, 0x1fb92],
+ [0x1fb94, 0x1fbca],
+ [0x1fbf0, 0x1fbf9],
+ [0x20000],
+ [0x2a6df],
+ [0x2a700],
+ [0x2b739],
+ [0x2b740],
+ [0x2b81d],
+ [0x2b820],
+ [0x2cea1],
+ [0x2ceb0],
+ [0x2ebe0],
+ [0x2ebf0],
+ [0x2ee5d],
+ [0x2f800, 0x2fa1d],
+ [0x30000],
+ [0x3134a],
+ [0x31350],
+ [0x323af],
+];
+exports.autonomousDecomposableGraphemeRanges = [
+ [0xc0, 0xc5],
+ [0xc7, 0xcf],
+ [0xd1, 0xd6],
+ [0xd9, 0xdd],
+ [0xe0, 0xe5],
+ [0xe7, 0xef],
+ [0xf1, 0xf6],
+ [0xf9, 0xfd],
+ [0xff, 0x10f],
+ [0x112, 0x125],
+ [0x128, 0x130],
+ [0x134, 0x137],
+ [0x139, 0x13e],
+ [0x143, 0x148],
+ [0x14c, 0x151],
+ [0x154, 0x165],
+ [0x168, 0x17e],
+ [0x1a0, 0x1a1],
+ [0x1af, 0x1b0],
+ [0x1cd, 0x1dc],
+ [0x1de, 0x1e3],
+ [0x1e6, 0x1f0],
+ [0x1f4, 0x1f5],
+ [0x1f8, 0x21b],
+ [0x21e, 0x21f],
+ [0x226, 0x233],
+ [0x385, 0x386],
+ [0x388, 0x38a],
+ [0x38c],
+ [0x38e, 0x390],
+ [0x3aa, 0x3b0],
+ [0x3ca, 0x3ce],
+ [0x3d3, 0x3d4],
+ [0x400, 0x401],
+ [0x403],
+ [0x407],
+ [0x40c, 0x40e],
+ [0x419],
+ [0x439],
+ [0x450, 0x451],
+ [0x453],
+ [0x457],
+ [0x45c, 0x45e],
+ [0x476, 0x477],
+ [0x4c1, 0x4c2],
+ [0x4d0, 0x4d3],
+ [0x4d6, 0x4d7],
+ [0x4da, 0x4df],
+ [0x4e2, 0x4e7],
+ [0x4ea, 0x4f5],
+ [0x4f8, 0x4f9],
+ [0x622, 0x626],
+ [0x6c0],
+ [0x6c2],
+ [0x6d3],
+ [0x929],
+ [0x931],
+ [0x934],
+ [0x958, 0x95f],
+ [0x9dc, 0x9dd],
+ [0x9df],
+ [0xa33],
+ [0xa36],
+ [0xa59, 0xa5b],
+ [0xa5e],
+ [0xb5c, 0xb5d],
+ [0xb94],
+ [0xf43],
+ [0xf4d],
+ [0xf52],
+ [0xf57],
+ [0xf5c],
+ [0xf69],
+ [0x1026],
+ [0x1b06],
+ [0x1b08],
+ [0x1b0a],
+ [0x1b0c],
+ [0x1b0e],
+ [0x1b12],
+ [0x1e00, 0x1e99],
+ [0x1e9b],
+ [0x1ea0, 0x1ef9],
+ [0x1f00, 0x1f15],
+ [0x1f18, 0x1f1d],
+ [0x1f20, 0x1f45],
+ [0x1f48, 0x1f4d],
+ [0x1f50, 0x1f57],
+ [0x1f59],
+ [0x1f5b],
+ [0x1f5d],
+ [0x1f5f, 0x1f70],
+ [0x1f72],
+ [0x1f74],
+ [0x1f76],
+ [0x1f78],
+ [0x1f7a],
+ [0x1f7c],
+ [0x1f80, 0x1fb4],
+ [0x1fb6, 0x1fba],
+ [0x1fbc],
+ [0x1fc1, 0x1fc4],
+ [0x1fc6, 0x1fc8],
+ [0x1fca],
+ [0x1fcc, 0x1fd2],
+ [0x1fd6, 0x1fda],
+ [0x1fdd, 0x1fe2],
+ [0x1fe4, 0x1fea],
+ [0x1fec, 0x1fed],
+ [0x1ff2, 0x1ff4],
+ [0x1ff6, 0x1ff8],
+ [0x1ffa],
+ [0x1ffc],
+ [0x219a, 0x219b],
+ [0x21ae],
+ [0x21cd, 0x21cf],
+ [0x2204],
+ [0x2209],
+ [0x220c],
+ [0x2224],
+ [0x2226],
+ [0x2241],
+ [0x2244],
+ [0x2247],
+ [0x2249],
+ [0x2260],
+ [0x2262],
+ [0x226d, 0x2271],
+ [0x2274, 0x2275],
+ [0x2278, 0x2279],
+ [0x2280, 0x2281],
+ [0x2284, 0x2285],
+ [0x2288, 0x2289],
+ [0x22ac, 0x22af],
+ [0x22e0, 0x22e3],
+ [0x22ea, 0x22ed],
+ [0x2adc],
+ [0x304c],
+ [0x304e],
+ [0x3050],
+ [0x3052],
+ [0x3054],
+ [0x3056],
+ [0x3058],
+ [0x305a],
+ [0x305c],
+ [0x305e],
+ [0x3060],
+ [0x3062],
+ [0x3065],
+ [0x3067],
+ [0x3069],
+ [0x3070, 0x3071],
+ [0x3073, 0x3074],
+ [0x3076, 0x3077],
+ [0x3079, 0x307a],
+ [0x307c, 0x307d],
+ [0x3094],
+ [0x309e],
+ [0x30ac],
+ [0x30ae],
+ [0x30b0],
+ [0x30b2],
+ [0x30b4],
+ [0x30b6],
+ [0x30b8],
+ [0x30ba],
+ [0x30bc],
+ [0x30be],
+ [0x30c0],
+ [0x30c2],
+ [0x30c5],
+ [0x30c7],
+ [0x30c9],
+ [0x30d0, 0x30d1],
+ [0x30d3, 0x30d4],
+ [0x30d6, 0x30d7],
+ [0x30d9, 0x30da],
+ [0x30dc, 0x30dd],
+ [0x30f4],
+ [0x30f7, 0x30fa],
+ [0x30fe],
+ [0xac00],
+ [0xd7a3],
+ [0xfb1d],
+ [0xfb1f],
+ [0xfb2a, 0xfb36],
+ [0xfb38, 0xfb3c],
+ [0xfb3e],
+ [0xfb40, 0xfb41],
+ [0xfb43, 0xfb44],
+ [0xfb46, 0xfb4e],
+ [0x1109a],
+ [0x1109c],
+ [0x110ab],
+ [0x1d15e, 0x1d164],
+ [0x1d1bb, 0x1d1c0],
+];
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/helpers/ArrayInt64.js b/node_modules/fast-check/lib/arbitrary/_internals/helpers/ArrayInt64.js
new file mode 100644
index 0000000000000000000000000000000000000000..f8fc62c32df67119d29e56f6c1d6c306176e263f
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/helpers/ArrayInt64.js
@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Unit64 = exports.Zero64 = void 0;
+exports.isZero64 = isZero64;
+exports.isStrictlyNegative64 = isStrictlyNegative64;
+exports.isStrictlyPositive64 = isStrictlyPositive64;
+exports.isEqual64 = isEqual64;
+exports.isStrictlySmaller64 = isStrictlySmaller64;
+exports.clone64 = clone64;
+exports.substract64 = substract64;
+exports.negative64 = negative64;
+exports.add64 = add64;
+exports.halve64 = halve64;
+exports.logLike64 = logLike64;
+exports.Zero64 = { sign: 1, data: [0, 0] };
+exports.Unit64 = { sign: 1, data: [0, 1] };
+function isZero64(a) {
+ return a.data[0] === 0 && a.data[1] === 0;
+}
+function isStrictlyNegative64(a) {
+ return a.sign === -1 && !isZero64(a);
+}
+function isStrictlyPositive64(a) {
+ return a.sign === 1 && !isZero64(a);
+}
+function isEqual64(a, b) {
+ if (a.data[0] === b.data[0] && a.data[1] === b.data[1]) {
+ return a.sign === b.sign || (a.data[0] === 0 && a.data[1] === 0);
+ }
+ return false;
+}
+function isStrictlySmaller64Internal(a, b) {
+ return a[0] < b[0] || (a[0] === b[0] && a[1] < b[1]);
+}
+function isStrictlySmaller64(a, b) {
+ if (a.sign === b.sign) {
+ return a.sign === 1
+ ? isStrictlySmaller64Internal(a.data, b.data)
+ : isStrictlySmaller64Internal(b.data, a.data);
+ }
+ return a.sign === -1 && (!isZero64(a) || !isZero64(b));
+}
+function clone64(a) {
+ return { sign: a.sign, data: [a.data[0], a.data[1]] };
+}
+function substract64DataInternal(a, b) {
+ let reminderLow = 0;
+ let low = a[1] - b[1];
+ if (low < 0) {
+ reminderLow = 1;
+ low = low >>> 0;
+ }
+ return [a[0] - b[0] - reminderLow, low];
+}
+function substract64Internal(a, b) {
+ if (a.sign === 1 && b.sign === -1) {
+ const low = a.data[1] + b.data[1];
+ const high = a.data[0] + b.data[0] + (low > 0xffffffff ? 1 : 0);
+ return { sign: 1, data: [high >>> 0, low >>> 0] };
+ }
+ return {
+ sign: 1,
+ data: a.sign === 1 ? substract64DataInternal(a.data, b.data) : substract64DataInternal(b.data, a.data),
+ };
+}
+function substract64(arrayIntA, arrayIntB) {
+ if (isStrictlySmaller64(arrayIntA, arrayIntB)) {
+ const out = substract64Internal(arrayIntB, arrayIntA);
+ out.sign = -1;
+ return out;
+ }
+ return substract64Internal(arrayIntA, arrayIntB);
+}
+function negative64(arrayIntA) {
+ return {
+ sign: -arrayIntA.sign,
+ data: [arrayIntA.data[0], arrayIntA.data[1]],
+ };
+}
+function add64(arrayIntA, arrayIntB) {
+ if (isZero64(arrayIntB)) {
+ if (isZero64(arrayIntA)) {
+ return clone64(exports.Zero64);
+ }
+ return clone64(arrayIntA);
+ }
+ return substract64(arrayIntA, negative64(arrayIntB));
+}
+function halve64(a) {
+ return {
+ sign: a.sign,
+ data: [Math.floor(a.data[0] / 2), (a.data[0] % 2 === 1 ? 0x80000000 : 0) + Math.floor(a.data[1] / 2)],
+ };
+}
+function logLike64(a) {
+ return {
+ sign: a.sign,
+ data: [0, Math.floor(Math.log(a.data[0] * 0x100000000 + a.data[1]) / Math.log(2))],
+ };
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/helpers/BiasNumericRange.js b/node_modules/fast-check/lib/arbitrary/_internals/helpers/BiasNumericRange.js
new file mode 100644
index 0000000000000000000000000000000000000000..2e9bfde4cabe908e9ace379ba1fc4b5e7c873d01
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/helpers/BiasNumericRange.js
@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.integerLogLike = integerLogLike;
+exports.bigIntLogLike = bigIntLogLike;
+exports.biasNumericRange = biasNumericRange;
+const globals_1 = require("../../../utils/globals");
+const safeMathFloor = Math.floor;
+const safeMathLog = Math.log;
+function integerLogLike(v) {
+ return safeMathFloor(safeMathLog(v) / safeMathLog(2));
+}
+function bigIntLogLike(v) {
+ if (v === (0, globals_1.BigInt)(0))
+ return (0, globals_1.BigInt)(0);
+ return (0, globals_1.BigInt)((0, globals_1.String)(v).length);
+}
+function biasNumericRange(min, max, logLike) {
+ if (min === max) {
+ return [{ min: min, max: max }];
+ }
+ if (min < 0 && max > 0) {
+ const logMin = logLike(-min);
+ const logMax = logLike(max);
+ return [
+ { min: -logMin, max: logMax },
+ { min: (max - logMax), max: max },
+ { min: min, max: min + logMin },
+ ];
+ }
+ const logGap = logLike((max - min));
+ const arbCloseToMin = { min: min, max: min + logGap };
+ const arbCloseToMax = { min: (max - logGap), max: max };
+ return min < 0
+ ? [arbCloseToMax, arbCloseToMin]
+ : [arbCloseToMin, arbCloseToMax];
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/helpers/BuildSchedulerFor.js b/node_modules/fast-check/lib/arbitrary/_internals/helpers/BuildSchedulerFor.js
new file mode 100644
index 0000000000000000000000000000000000000000..e07679532a2dc745f61e6cd3d407485ca0db989e
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/helpers/BuildSchedulerFor.js
@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSchedulerFor = buildSchedulerFor;
+const SchedulerImplem_1 = require("../implementations/SchedulerImplem");
+function buildNextTaskIndex(ordering) {
+ let numTasks = 0;
+ return {
+ clone: () => buildNextTaskIndex(ordering),
+ nextTaskIndex: (scheduledTasks) => {
+ if (ordering.length <= numTasks) {
+ throw new Error(`Invalid schedulerFor defined: too many tasks have been scheduled`);
+ }
+ const taskIndex = scheduledTasks.findIndex((t) => t.taskId === ordering[numTasks]);
+ if (taskIndex === -1) {
+ throw new Error(`Invalid schedulerFor defined: unable to find next task`);
+ }
+ ++numTasks;
+ return taskIndex;
+ },
+ };
+}
+function buildSchedulerFor(act, ordering) {
+ return new SchedulerImplem_1.SchedulerImplem(act, buildNextTaskIndex(ordering));
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/helpers/BuildSlicedGenerator.js b/node_modules/fast-check/lib/arbitrary/_internals/helpers/BuildSlicedGenerator.js
new file mode 100644
index 0000000000000000000000000000000000000000..91dc1d9db769428057bd5669c6ade845128cb45d
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/helpers/BuildSlicedGenerator.js
@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSlicedGenerator = buildSlicedGenerator;
+const NoopSlicedGenerator_1 = require("../implementations/NoopSlicedGenerator");
+const SlicedBasedGenerator_1 = require("../implementations/SlicedBasedGenerator");
+function buildSlicedGenerator(arb, mrng, slices, biasFactor) {
+ if (biasFactor === undefined || slices.length === 0 || mrng.nextInt(1, biasFactor) !== 1) {
+ return new NoopSlicedGenerator_1.NoopSlicedGenerator(arb, mrng, biasFactor);
+ }
+ return new SlicedBasedGenerator_1.SlicedBasedGenerator(arb, mrng, slices, biasFactor);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/helpers/CustomEqualSet.js b/node_modules/fast-check/lib/arbitrary/_internals/helpers/CustomEqualSet.js
new file mode 100644
index 0000000000000000000000000000000000000000..f1eea75e744871b2bced1762761c5ad711964ffa
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/helpers/CustomEqualSet.js
@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomEqualSet = void 0;
+const globals_1 = require("../../../utils/globals");
+class CustomEqualSet {
+ constructor(isEqual) {
+ this.isEqual = isEqual;
+ this.data = [];
+ }
+ tryAdd(value) {
+ for (let idx = 0; idx !== this.data.length; ++idx) {
+ if (this.isEqual(this.data[idx], value)) {
+ return false;
+ }
+ }
+ (0, globals_1.safePush)(this.data, value);
+ return true;
+ }
+ size() {
+ return this.data.length;
+ }
+ getData() {
+ return this.data;
+ }
+}
+exports.CustomEqualSet = CustomEqualSet;
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/helpers/DepthContext.js b/node_modules/fast-check/lib/arbitrary/_internals/helpers/DepthContext.js
new file mode 100644
index 0000000000000000000000000000000000000000..be977eeb6a66e080b8e1fe356e29a5c40efba3d6
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/helpers/DepthContext.js
@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDepthContextFor = getDepthContextFor;
+exports.createDepthIdentifier = createDepthIdentifier;
+const globals_1 = require("../../../utils/globals");
+const depthContextCache = new Map();
+function getDepthContextFor(contextMeta) {
+ if (contextMeta === undefined) {
+ return { depth: 0 };
+ }
+ if (typeof contextMeta !== 'string') {
+ return contextMeta;
+ }
+ const cachedContext = (0, globals_1.safeMapGet)(depthContextCache, contextMeta);
+ if (cachedContext !== undefined) {
+ return cachedContext;
+ }
+ const context = { depth: 0 };
+ (0, globals_1.safeMapSet)(depthContextCache, contextMeta, context);
+ return context;
+}
+function createDepthIdentifier() {
+ const identifier = { depth: 0 };
+ return identifier;
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/helpers/DoubleHelpers.js b/node_modules/fast-check/lib/arbitrary/_internals/helpers/DoubleHelpers.js
new file mode 100644
index 0000000000000000000000000000000000000000..07ee7ad71626ed3a3da26209bb2fe85cb0e43e8a
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/helpers/DoubleHelpers.js
@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decomposeDouble = decomposeDouble;
+exports.doubleToIndex = doubleToIndex;
+exports.indexToDouble = indexToDouble;
+const ArrayInt64_1 = require("./ArrayInt64");
+const safeNegativeInfinity = Number.NEGATIVE_INFINITY;
+const safePositiveInfinity = Number.POSITIVE_INFINITY;
+const safeEpsilon = Number.EPSILON;
+const INDEX_POSITIVE_INFINITY = { sign: 1, data: [2146435072, 0] };
+const INDEX_NEGATIVE_INFINITY = { sign: -1, data: [2146435072, 1] };
+const f64 = new Float64Array(1);
+const u32 = new Uint32Array(f64.buffer, f64.byteOffset);
+function bitCastDoubleToUInt64(f) {
+ f64[0] = f;
+ return [u32[1], u32[0]];
+}
+function decomposeDouble(d) {
+ const { 0: hi, 1: lo } = bitCastDoubleToUInt64(d);
+ const signBit = hi >>> 31;
+ const exponentBits = (hi >>> 20) & 0x7ff;
+ const significandBits = (hi & 0xfffff) * 0x100000000 + lo;
+ const exponent = exponentBits === 0 ? -1022 : exponentBits - 1023;
+ let significand = exponentBits === 0 ? 0 : 1;
+ significand += significandBits / 2 ** 52;
+ significand *= signBit === 0 ? 1 : -1;
+ return { exponent, significand };
+}
+function positiveNumberToInt64(n) {
+ return [~~(n / 0x100000000), n >>> 0];
+}
+function indexInDoubleFromDecomp(exponent, significand) {
+ if (exponent === -1022) {
+ const rescaledSignificand = significand * 2 ** 52;
+ return positiveNumberToInt64(rescaledSignificand);
+ }
+ const rescaledSignificand = (significand - 1) * 2 ** 52;
+ const exponentOnlyHigh = (exponent + 1023) * 2 ** 20;
+ const index = positiveNumberToInt64(rescaledSignificand);
+ index[0] += exponentOnlyHigh;
+ return index;
+}
+function doubleToIndex(d) {
+ if (d === safePositiveInfinity) {
+ return (0, ArrayInt64_1.clone64)(INDEX_POSITIVE_INFINITY);
+ }
+ if (d === safeNegativeInfinity) {
+ return (0, ArrayInt64_1.clone64)(INDEX_NEGATIVE_INFINITY);
+ }
+ const decomp = decomposeDouble(d);
+ const exponent = decomp.exponent;
+ const significand = decomp.significand;
+ if (d > 0 || (d === 0 && 1 / d === safePositiveInfinity)) {
+ return { sign: 1, data: indexInDoubleFromDecomp(exponent, significand) };
+ }
+ else {
+ const indexOpposite = indexInDoubleFromDecomp(exponent, -significand);
+ if (indexOpposite[1] === 0xffffffff) {
+ indexOpposite[0] += 1;
+ indexOpposite[1] = 0;
+ }
+ else {
+ indexOpposite[1] += 1;
+ }
+ return { sign: -1, data: indexOpposite };
+ }
+}
+function indexToDouble(index) {
+ if (index.sign === -1) {
+ const indexOpposite = { sign: 1, data: [index.data[0], index.data[1]] };
+ if (indexOpposite.data[1] === 0) {
+ indexOpposite.data[0] -= 1;
+ indexOpposite.data[1] = 0xffffffff;
+ }
+ else {
+ indexOpposite.data[1] -= 1;
+ }
+ return -indexToDouble(indexOpposite);
+ }
+ if ((0, ArrayInt64_1.isEqual64)(index, INDEX_POSITIVE_INFINITY)) {
+ return safePositiveInfinity;
+ }
+ if (index.data[0] < 0x200000) {
+ return (index.data[0] * 0x100000000 + index.data[1]) * 2 ** -1074;
+ }
+ const postIndexHigh = index.data[0] - 0x200000;
+ const exponent = -1021 + (postIndexHigh >> 20);
+ const significand = 1 + ((postIndexHigh & 0xfffff) * 2 ** 32 + index.data[1]) * safeEpsilon;
+ return significand * 2 ** exponent;
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/helpers/DoubleOnlyHelpers.js b/node_modules/fast-check/lib/arbitrary/_internals/helpers/DoubleOnlyHelpers.js
new file mode 100644
index 0000000000000000000000000000000000000000..a886022958fb7644c8bb7dcb87b998f5d5a32378
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/helpers/DoubleOnlyHelpers.js
@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onlyIntegersAfterThisValue = exports.maxNonIntegerValue = void 0;
+exports.refineConstraintsForDoubleOnly = refineConstraintsForDoubleOnly;
+exports.doubleOnlyMapper = doubleOnlyMapper;
+exports.doubleOnlyUnmapper = doubleOnlyUnmapper;
+const FloatingOnlyHelpers_1 = require("./FloatingOnlyHelpers");
+const safeNegativeInfinity = Number.NEGATIVE_INFINITY;
+const safePositiveInfinity = Number.POSITIVE_INFINITY;
+const safeMaxValue = Number.MAX_VALUE;
+exports.maxNonIntegerValue = 4503599627370495.5;
+exports.onlyIntegersAfterThisValue = 4503599627370496;
+function refineConstraintsForDoubleOnly(constraints) {
+ return (0, FloatingOnlyHelpers_1.refineConstraintsForFloatingOnly)(constraints, safeMaxValue, exports.maxNonIntegerValue, exports.onlyIntegersAfterThisValue);
+}
+function doubleOnlyMapper(value) {
+ return value === exports.onlyIntegersAfterThisValue
+ ? safePositiveInfinity
+ : value === -exports.onlyIntegersAfterThisValue
+ ? safeNegativeInfinity
+ : value;
+}
+function doubleOnlyUnmapper(value) {
+ if (typeof value !== 'number')
+ throw new Error('Unsupported type');
+ return value === safePositiveInfinity
+ ? exports.onlyIntegersAfterThisValue
+ : value === safeNegativeInfinity
+ ? -exports.onlyIntegersAfterThisValue
+ : value;
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/helpers/EnumerableKeysExtractor.js b/node_modules/fast-check/lib/arbitrary/_internals/helpers/EnumerableKeysExtractor.js
new file mode 100644
index 0000000000000000000000000000000000000000..6db29804d711ee50584c02aaafd301f2e34742a7
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/helpers/EnumerableKeysExtractor.js
@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractEnumerableKeys = extractEnumerableKeys;
+const safeObjectKeys = Object.keys;
+const safeObjectGetOwnPropertySymbols = Object.getOwnPropertySymbols;
+const safeObjectGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+function extractEnumerableKeys(instance) {
+ const keys = safeObjectKeys(instance);
+ const symbols = safeObjectGetOwnPropertySymbols(instance);
+ for (let index = 0; index !== symbols.length; ++index) {
+ const symbol = symbols[index];
+ const descriptor = safeObjectGetOwnPropertyDescriptor(instance, symbol);
+ if (descriptor && descriptor.enumerable) {
+ keys.push(symbol);
+ }
+ }
+ return keys;
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/helpers/FloatHelpers.js b/node_modules/fast-check/lib/arbitrary/_internals/helpers/FloatHelpers.js
new file mode 100644
index 0000000000000000000000000000000000000000..4e6e3f1459411163f95c9c9bdc53f08acea771fa
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/helpers/FloatHelpers.js
@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EPSILON_32 = exports.MAX_VALUE_32 = exports.MIN_VALUE_32 = void 0;
+exports.decomposeFloat = decomposeFloat;
+exports.floatToIndex = floatToIndex;
+exports.indexToFloat = indexToFloat;
+const safeNegativeInfinity = Number.NEGATIVE_INFINITY;
+const safePositiveInfinity = Number.POSITIVE_INFINITY;
+exports.MIN_VALUE_32 = 2 ** -126 * 2 ** -23;
+exports.MAX_VALUE_32 = 2 ** 127 * (1 + (2 ** 23 - 1) / 2 ** 23);
+exports.EPSILON_32 = 2 ** -23;
+const INDEX_POSITIVE_INFINITY = 2139095040;
+const INDEX_NEGATIVE_INFINITY = -2139095041;
+const f32 = new Float32Array(1);
+const u32 = new Uint32Array(f32.buffer, f32.byteOffset);
+function bitCastFloatToUInt32(f) {
+ f32[0] = f;
+ return u32[0];
+}
+function decomposeFloat(f) {
+ const bits = bitCastFloatToUInt32(f);
+ const signBit = bits >>> 31;
+ const exponentBits = (bits >>> 23) & 0xff;
+ const significandBits = bits & 0x7fffff;
+ const exponent = exponentBits === 0 ? -126 : exponentBits - 127;
+ let significand = exponentBits === 0 ? 0 : 1;
+ significand += significandBits / 2 ** 23;
+ significand *= signBit === 0 ? 1 : -1;
+ return { exponent, significand };
+}
+function indexInFloatFromDecomp(exponent, significand) {
+ if (exponent === -126) {
+ return significand * 0x800000;
+ }
+ return (exponent + 127) * 0x800000 + (significand - 1) * 0x800000;
+}
+function floatToIndex(f) {
+ if (f === safePositiveInfinity) {
+ return INDEX_POSITIVE_INFINITY;
+ }
+ if (f === safeNegativeInfinity) {
+ return INDEX_NEGATIVE_INFINITY;
+ }
+ const decomp = decomposeFloat(f);
+ const exponent = decomp.exponent;
+ const significand = decomp.significand;
+ if (f > 0 || (f === 0 && 1 / f === safePositiveInfinity)) {
+ return indexInFloatFromDecomp(exponent, significand);
+ }
+ else {
+ return -indexInFloatFromDecomp(exponent, -significand) - 1;
+ }
+}
+function indexToFloat(index) {
+ if (index < 0) {
+ return -indexToFloat(-index - 1);
+ }
+ if (index === INDEX_POSITIVE_INFINITY) {
+ return safePositiveInfinity;
+ }
+ if (index < 0x1000000) {
+ return index * 2 ** -149;
+ }
+ const postIndex = index - 0x1000000;
+ const exponent = -125 + (postIndex >> 23);
+ const significand = 1 + (postIndex & 0x7fffff) / 0x800000;
+ return significand * 2 ** exponent;
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/helpers/FloatOnlyHelpers.js b/node_modules/fast-check/lib/arbitrary/_internals/helpers/FloatOnlyHelpers.js
new file mode 100644
index 0000000000000000000000000000000000000000..d0426a9bc8e8c327e2a97a3f90faa513e5e7682b
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/helpers/FloatOnlyHelpers.js
@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onlyIntegersAfterThisValue = exports.maxNonIntegerValue = void 0;
+exports.refineConstraintsForFloatOnly = refineConstraintsForFloatOnly;
+exports.floatOnlyMapper = floatOnlyMapper;
+exports.floatOnlyUnmapper = floatOnlyUnmapper;
+const FloatHelpers_1 = require("./FloatHelpers");
+const FloatingOnlyHelpers_1 = require("./FloatingOnlyHelpers");
+const safeNegativeInfinity = Number.NEGATIVE_INFINITY;
+const safePositiveInfinity = Number.POSITIVE_INFINITY;
+const safeMaxValue = FloatHelpers_1.MAX_VALUE_32;
+exports.maxNonIntegerValue = 8388607.5;
+exports.onlyIntegersAfterThisValue = 8388608;
+function refineConstraintsForFloatOnly(constraints) {
+ return (0, FloatingOnlyHelpers_1.refineConstraintsForFloatingOnly)(constraints, safeMaxValue, exports.maxNonIntegerValue, exports.onlyIntegersAfterThisValue);
+}
+function floatOnlyMapper(value) {
+ return value === exports.onlyIntegersAfterThisValue
+ ? safePositiveInfinity
+ : value === -exports.onlyIntegersAfterThisValue
+ ? safeNegativeInfinity
+ : value;
+}
+function floatOnlyUnmapper(value) {
+ if (typeof value !== 'number')
+ throw new Error('Unsupported type');
+ return value === safePositiveInfinity
+ ? exports.onlyIntegersAfterThisValue
+ : value === safeNegativeInfinity
+ ? -exports.onlyIntegersAfterThisValue
+ : value;
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/helpers/FloatingOnlyHelpers.js b/node_modules/fast-check/lib/arbitrary/_internals/helpers/FloatingOnlyHelpers.js
new file mode 100644
index 0000000000000000000000000000000000000000..1ab87b1539b1bc1be29657939d33c7733b3d0206
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/helpers/FloatingOnlyHelpers.js
@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.refineConstraintsForFloatingOnly = refineConstraintsForFloatingOnly;
+const safeNumberIsInteger = Number.isInteger;
+const safeObjectIs = Object.is;
+const safeNegativeInfinity = Number.NEGATIVE_INFINITY;
+const safePositiveInfinity = Number.POSITIVE_INFINITY;
+function refineConstraintsForFloatingOnly(constraints, maxValue, maxNonIntegerValue, onlyIntegersAfterThisValue) {
+ const { noDefaultInfinity = false, minExcluded = false, maxExcluded = false, min = noDefaultInfinity ? -maxValue : safeNegativeInfinity, max = noDefaultInfinity ? maxValue : safePositiveInfinity, } = constraints;
+ const effectiveMin = minExcluded
+ ? min < -maxNonIntegerValue
+ ? -onlyIntegersAfterThisValue
+ : Math.max(min, -maxNonIntegerValue)
+ : min === safeNegativeInfinity
+ ? Math.max(min, -onlyIntegersAfterThisValue)
+ : Math.max(min, -maxNonIntegerValue);
+ const effectiveMax = maxExcluded
+ ? max > maxNonIntegerValue
+ ? onlyIntegersAfterThisValue
+ : Math.min(max, maxNonIntegerValue)
+ : max === safePositiveInfinity
+ ? Math.min(max, onlyIntegersAfterThisValue)
+ : Math.min(max, maxNonIntegerValue);
+ const fullConstraints = {
+ noDefaultInfinity: false,
+ minExcluded: minExcluded || ((min !== safeNegativeInfinity || minExcluded) && safeNumberIsInteger(effectiveMin)),
+ maxExcluded: maxExcluded || ((max !== safePositiveInfinity || maxExcluded) && safeNumberIsInteger(effectiveMax)),
+ min: safeObjectIs(effectiveMin, -0) ? 0 : effectiveMin,
+ max: safeObjectIs(effectiveMax, 0) ? -0 : effectiveMax,
+ noNaN: constraints.noNaN || false,
+ };
+ return fullConstraints;
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/helpers/GraphemeRangesHelpers.js b/node_modules/fast-check/lib/arbitrary/_internals/helpers/GraphemeRangesHelpers.js
new file mode 100644
index 0000000000000000000000000000000000000000..c1c71287b9dd69cefc7ae3d4ce8cae7523c2fe04
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/helpers/GraphemeRangesHelpers.js
@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertGraphemeRangeToMapToConstantEntry = convertGraphemeRangeToMapToConstantEntry;
+exports.intersectGraphemeRanges = intersectGraphemeRanges;
+const globals_1 = require("../../../utils/globals");
+const safeStringFromCodePoint = String.fromCodePoint;
+const safeMathMin = Math.min;
+const safeMathMax = Math.max;
+function convertGraphemeRangeToMapToConstantEntry(range) {
+ if (range.length === 1) {
+ const codePointString = safeStringFromCodePoint(range[0]);
+ return { num: 1, build: () => codePointString };
+ }
+ const rangeStart = range[0];
+ return { num: range[1] - range[0] + 1, build: (idInGroup) => safeStringFromCodePoint(rangeStart + idInGroup) };
+}
+function intersectGraphemeRanges(rangesA, rangesB) {
+ const mergedRanges = [];
+ let cursorA = 0;
+ let cursorB = 0;
+ while (cursorA < rangesA.length && cursorB < rangesB.length) {
+ const rangeA = rangesA[cursorA];
+ const rangeAMin = rangeA[0];
+ const rangeAMax = rangeA.length === 1 ? rangeA[0] : rangeA[1];
+ const rangeB = rangesB[cursorB];
+ const rangeBMin = rangeB[0];
+ const rangeBMax = rangeB.length === 1 ? rangeB[0] : rangeB[1];
+ if (rangeAMax < rangeBMin) {
+ cursorA += 1;
+ }
+ else if (rangeBMax < rangeAMin) {
+ cursorB += 1;
+ }
+ else {
+ let min = safeMathMax(rangeAMin, rangeBMin);
+ const max = safeMathMin(rangeAMax, rangeBMax);
+ if (mergedRanges.length >= 1) {
+ const lastMergedRange = mergedRanges[mergedRanges.length - 1];
+ const lastMergedRangeMax = lastMergedRange.length === 1 ? lastMergedRange[0] : lastMergedRange[1];
+ if (lastMergedRangeMax + 1 === min) {
+ min = lastMergedRange[0];
+ (0, globals_1.safePop)(mergedRanges);
+ }
+ }
+ (0, globals_1.safePush)(mergedRanges, min === max ? [min] : [min, max]);
+ if (rangeAMax <= max) {
+ cursorA += 1;
+ }
+ if (rangeBMax <= max) {
+ cursorB += 1;
+ }
+ }
+ }
+ return mergedRanges;
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/helpers/InvalidSubdomainLabelFiIter.js b/node_modules/fast-check/lib/arbitrary/_internals/helpers/InvalidSubdomainLabelFiIter.js
new file mode 100644
index 0000000000000000000000000000000000000000..11d20e26bf14d88db468165e9e5b0121669e4627
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/helpers/InvalidSubdomainLabelFiIter.js
@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterInvalidSubdomainLabel = filterInvalidSubdomainLabel;
+function filterInvalidSubdomainLabel(subdomainLabel) {
+ if (subdomainLabel.length > 63) {
+ return false;
+ }
+ return (subdomainLabel.length < 4 ||
+ subdomainLabel[0] !== 'x' ||
+ subdomainLabel[1] !== 'n' ||
+ subdomainLabel[2] !== '-' ||
+ subdomainLabel[3] !== '-');
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/helpers/IsSubarrayOf.js b/node_modules/fast-check/lib/arbitrary/_internals/helpers/IsSubarrayOf.js
new file mode 100644
index 0000000000000000000000000000000000000000..3e49a74a6baf9c6a471c53d4ed4df799e1c9cc96
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/helpers/IsSubarrayOf.js
@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSubarrayOf = isSubarrayOf;
+const globals_1 = require("../../../utils/globals");
+const safeObjectIs = Object.is;
+function isSubarrayOf(source, small) {
+ const countMap = new globals_1.Map();
+ let countMinusZero = 0;
+ for (const sourceEntry of source) {
+ if (safeObjectIs(sourceEntry, -0)) {
+ ++countMinusZero;
+ }
+ else {
+ const oldCount = (0, globals_1.safeMapGet)(countMap, sourceEntry) || 0;
+ (0, globals_1.safeMapSet)(countMap, sourceEntry, oldCount + 1);
+ }
+ }
+ for (let index = 0; index !== small.length; ++index) {
+ if (!(index in small)) {
+ return false;
+ }
+ const smallEntry = small[index];
+ if (safeObjectIs(smallEntry, -0)) {
+ if (countMinusZero === 0)
+ return false;
+ --countMinusZero;
+ }
+ else {
+ const oldCount = (0, globals_1.safeMapGet)(countMap, smallEntry) || 0;
+ if (oldCount === 0)
+ return false;
+ (0, globals_1.safeMapSet)(countMap, smallEntry, oldCount - 1);
+ }
+ }
+ return true;
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/helpers/JsonConstraintsBuilder.js b/node_modules/fast-check/lib/arbitrary/_internals/helpers/JsonConstraintsBuilder.js
new file mode 100644
index 0000000000000000000000000000000000000000..01e17a268fb50b0115cfb57c279e79dbe35e561c
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/helpers/JsonConstraintsBuilder.js
@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsonConstraintsBuilder = jsonConstraintsBuilder;
+const boolean_1 = require("../../boolean");
+const constant_1 = require("../../constant");
+const double_1 = require("../../double");
+function jsonConstraintsBuilder(stringArbitrary, constraints) {
+ const { depthSize, maxDepth } = constraints;
+ const key = stringArbitrary;
+ const values = [
+ (0, boolean_1.boolean)(),
+ (0, double_1.double)({ noDefaultInfinity: true, noNaN: true }),
+ stringArbitrary,
+ (0, constant_1.constant)(null),
+ ];
+ return { key, values, depthSize, maxDepth };
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/helpers/MaxLengthFromMinLength.js b/node_modules/fast-check/lib/arbitrary/_internals/helpers/MaxLengthFromMinLength.js
new file mode 100644
index 0000000000000000000000000000000000000000..07b03e6dd61217f201be1367a8c4082f9ba9dcda
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/helpers/MaxLengthFromMinLength.js
@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultSize = exports.MaxLengthUpperBound = void 0;
+exports.maxLengthFromMinLength = maxLengthFromMinLength;
+exports.relativeSizeToSize = relativeSizeToSize;
+exports.maxGeneratedLengthFromSizeForArbitrary = maxGeneratedLengthFromSizeForArbitrary;
+exports.depthBiasFromSizeForArbitrary = depthBiasFromSizeForArbitrary;
+exports.resolveSize = resolveSize;
+const GlobalParameters_1 = require("../../../check/runner/configuration/GlobalParameters");
+const globals_1 = require("../../../utils/globals");
+const safeMathFloor = Math.floor;
+const safeMathMin = Math.min;
+exports.MaxLengthUpperBound = 0x7fffffff;
+const orderedSize = ['xsmall', 'small', 'medium', 'large', 'xlarge'];
+const orderedRelativeSize = ['-4', '-3', '-2', '-1', '=', '+1', '+2', '+3', '+4'];
+exports.DefaultSize = 'small';
+function maxLengthFromMinLength(minLength, size) {
+ switch (size) {
+ case 'xsmall':
+ return safeMathFloor(1.1 * minLength) + 1;
+ case 'small':
+ return 2 * minLength + 10;
+ case 'medium':
+ return 11 * minLength + 100;
+ case 'large':
+ return 101 * minLength + 1000;
+ case 'xlarge':
+ return 1001 * minLength + 10000;
+ default:
+ throw new Error(`Unable to compute lengths based on received size: ${size}`);
+ }
+}
+function relativeSizeToSize(size, defaultSize) {
+ const sizeInRelative = (0, globals_1.safeIndexOf)(orderedRelativeSize, size);
+ if (sizeInRelative === -1) {
+ return size;
+ }
+ const defaultSizeInSize = (0, globals_1.safeIndexOf)(orderedSize, defaultSize);
+ if (defaultSizeInSize === -1) {
+ throw new Error(`Unable to offset size based on the unknown defaulted one: ${defaultSize}`);
+ }
+ const resultingSizeInSize = defaultSizeInSize + sizeInRelative - 4;
+ return resultingSizeInSize < 0
+ ? orderedSize[0]
+ : resultingSizeInSize >= orderedSize.length
+ ? orderedSize[orderedSize.length - 1]
+ : orderedSize[resultingSizeInSize];
+}
+function maxGeneratedLengthFromSizeForArbitrary(size, minLength, maxLength, specifiedMaxLength) {
+ const { baseSize: defaultSize = exports.DefaultSize, defaultSizeToMaxWhenMaxSpecified } = (0, GlobalParameters_1.readConfigureGlobal)() || {};
+ const definedSize = size !== undefined ? size : specifiedMaxLength && defaultSizeToMaxWhenMaxSpecified ? 'max' : defaultSize;
+ if (definedSize === 'max') {
+ return maxLength;
+ }
+ const finalSize = relativeSizeToSize(definedSize, defaultSize);
+ return safeMathMin(maxLengthFromMinLength(minLength, finalSize), maxLength);
+}
+function depthBiasFromSizeForArbitrary(depthSizeOrSize, specifiedMaxDepth) {
+ if (typeof depthSizeOrSize === 'number') {
+ return 1 / depthSizeOrSize;
+ }
+ const { baseSize: defaultSize = exports.DefaultSize, defaultSizeToMaxWhenMaxSpecified } = (0, GlobalParameters_1.readConfigureGlobal)() || {};
+ const definedSize = depthSizeOrSize !== undefined
+ ? depthSizeOrSize
+ : specifiedMaxDepth && defaultSizeToMaxWhenMaxSpecified
+ ? 'max'
+ : defaultSize;
+ if (definedSize === 'max') {
+ return 0;
+ }
+ const finalSize = relativeSizeToSize(definedSize, defaultSize);
+ switch (finalSize) {
+ case 'xsmall':
+ return 1;
+ case 'small':
+ return 0.5;
+ case 'medium':
+ return 0.25;
+ case 'large':
+ return 0.125;
+ case 'xlarge':
+ return 0.0625;
+ }
+}
+function resolveSize(size) {
+ const { baseSize: defaultSize = exports.DefaultSize } = (0, GlobalParameters_1.readConfigureGlobal)() || {};
+ if (size === undefined) {
+ return defaultSize;
+ }
+ return relativeSizeToSize(size, defaultSize);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/helpers/NoUndefinedAsContext.js b/node_modules/fast-check/lib/arbitrary/_internals/helpers/NoUndefinedAsContext.js
new file mode 100644
index 0000000000000000000000000000000000000000..681e3c6e5e4345ae245982034c5f9c7f6f0fd6d3
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/helpers/NoUndefinedAsContext.js
@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UndefinedContextPlaceholder = void 0;
+exports.noUndefinedAsContext = noUndefinedAsContext;
+const Value_1 = require("../../../check/arbitrary/definition/Value");
+exports.UndefinedContextPlaceholder = Symbol('UndefinedContextPlaceholder');
+function noUndefinedAsContext(value) {
+ if (value.context !== undefined) {
+ return value;
+ }
+ if (value.hasToBeCloned) {
+ return new Value_1.Value(value.value_, exports.UndefinedContextPlaceholder, () => value.value);
+ }
+ return new Value_1.Value(value.value_, exports.UndefinedContextPlaceholder);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/helpers/QualifiedObjectConstraints.js b/node_modules/fast-check/lib/arbitrary/_internals/helpers/QualifiedObjectConstraints.js
new file mode 100644
index 0000000000000000000000000000000000000000..1e77c1ec805c38f37db77a130559732894b62386
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/helpers/QualifiedObjectConstraints.js
@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toQualifiedObjectConstraints = toQualifiedObjectConstraints;
+const boolean_1 = require("../../boolean");
+const constant_1 = require("../../constant");
+const double_1 = require("../../double");
+const fullUnicodeString_1 = require("../../fullUnicodeString");
+const maxSafeInteger_1 = require("../../maxSafeInteger");
+const oneof_1 = require("../../oneof");
+const string_1 = require("../../string");
+const BoxedArbitraryBuilder_1 = require("../builders/BoxedArbitraryBuilder");
+function defaultValues(constraints, stringArbitrary) {
+ return [
+ (0, boolean_1.boolean)(),
+ (0, maxSafeInteger_1.maxSafeInteger)(),
+ (0, double_1.double)(),
+ stringArbitrary(constraints),
+ (0, oneof_1.oneof)(stringArbitrary(constraints), (0, constant_1.constant)(null), (0, constant_1.constant)(undefined)),
+ ];
+}
+function boxArbitraries(arbs) {
+ return arbs.map((arb) => (0, BoxedArbitraryBuilder_1.boxedArbitraryBuilder)(arb));
+}
+function boxArbitrariesIfNeeded(arbs, boxEnabled) {
+ return boxEnabled ? boxArbitraries(arbs).concat(arbs) : arbs;
+}
+function toQualifiedObjectConstraints(settings = {}) {
+ function orDefault(optionalValue, defaultValue) {
+ return optionalValue !== undefined ? optionalValue : defaultValue;
+ }
+ const stringArbitrary = 'stringUnit' in settings ? string_1.string : settings.withUnicodeString ? fullUnicodeString_1.fullUnicodeString : string_1.string;
+ const valueConstraints = { size: settings.size, unit: settings.stringUnit };
+ return {
+ key: orDefault(settings.key, stringArbitrary(valueConstraints)),
+ values: boxArbitrariesIfNeeded(orDefault(settings.values, defaultValues(valueConstraints, stringArbitrary)), orDefault(settings.withBoxedValues, false)),
+ depthSize: settings.depthSize,
+ maxDepth: settings.maxDepth,
+ maxKeys: settings.maxKeys,
+ size: settings.size,
+ withSet: orDefault(settings.withSet, false),
+ withMap: orDefault(settings.withMap, false),
+ withObjectString: orDefault(settings.withObjectString, false),
+ withNullPrototype: orDefault(settings.withNullPrototype, false),
+ withBigInt: orDefault(settings.withBigInt, false),
+ withDate: orDefault(settings.withDate, false),
+ withTypedArray: orDefault(settings.withTypedArray, false),
+ withSparseArray: orDefault(settings.withSparseArray, false),
+ };
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/helpers/ReadRegex.js b/node_modules/fast-check/lib/arbitrary/_internals/helpers/ReadRegex.js
new file mode 100644
index 0000000000000000000000000000000000000000..26e268f6c41a79fb3d380144cd62e4ec81647f42
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/helpers/ReadRegex.js
@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenizerBlockMode = void 0;
+exports.readFrom = readFrom;
+function charSizeAt(text, pos) {
+ return text[pos] >= '\uD800' && text[pos] <= '\uDBFF' && text[pos + 1] >= '\uDC00' && text[pos + 1] <= '\uDFFF'
+ ? 2
+ : 1;
+}
+function isHexaDigit(char) {
+ return (char >= '0' && char <= '9') || (char >= 'a' && char <= 'f') || (char >= 'A' && char <= 'F');
+}
+function isDigit(char) {
+ return char >= '0' && char <= '9';
+}
+function squaredBracketBlockContentEndFrom(text, from) {
+ for (let index = from; index !== text.length; ++index) {
+ const char = text[index];
+ if (char === '\\') {
+ index += 1;
+ }
+ else if (char === ']') {
+ return index;
+ }
+ }
+ throw new Error(`Missing closing ']'`);
+}
+function parenthesisBlockContentEndFrom(text, from) {
+ let numExtraOpened = 0;
+ for (let index = from; index !== text.length; ++index) {
+ const char = text[index];
+ if (char === '\\') {
+ index += 1;
+ }
+ else if (char === ')') {
+ if (numExtraOpened === 0) {
+ return index;
+ }
+ numExtraOpened -= 1;
+ }
+ else if (char === '[') {
+ index = squaredBracketBlockContentEndFrom(text, index);
+ }
+ else if (char === '(') {
+ numExtraOpened += 1;
+ }
+ }
+ throw new Error(`Missing closing ')'`);
+}
+function curlyBracketBlockContentEndFrom(text, from) {
+ let foundComma = false;
+ for (let index = from; index !== text.length; ++index) {
+ const char = text[index];
+ if (isDigit(char)) {
+ }
+ else if (from === index) {
+ return -1;
+ }
+ else if (char === ',') {
+ if (foundComma) {
+ return -1;
+ }
+ foundComma = true;
+ }
+ else if (char === '}') {
+ return index;
+ }
+ else {
+ return -1;
+ }
+ }
+ return -1;
+}
+var TokenizerBlockMode;
+(function (TokenizerBlockMode) {
+ TokenizerBlockMode[TokenizerBlockMode["Full"] = 0] = "Full";
+ TokenizerBlockMode[TokenizerBlockMode["Character"] = 1] = "Character";
+})(TokenizerBlockMode || (exports.TokenizerBlockMode = TokenizerBlockMode = {}));
+function blockEndFrom(text, from, unicodeMode, mode) {
+ switch (text[from]) {
+ case '[': {
+ if (mode === TokenizerBlockMode.Character) {
+ return from + 1;
+ }
+ return squaredBracketBlockContentEndFrom(text, from + 1) + 1;
+ }
+ case '{': {
+ if (mode === TokenizerBlockMode.Character) {
+ return from + 1;
+ }
+ const foundEnd = curlyBracketBlockContentEndFrom(text, from + 1);
+ if (foundEnd === -1) {
+ return from + 1;
+ }
+ return foundEnd + 1;
+ }
+ case '(': {
+ if (mode === TokenizerBlockMode.Character) {
+ return from + 1;
+ }
+ return parenthesisBlockContentEndFrom(text, from + 1) + 1;
+ }
+ case ']':
+ case '}':
+ case ')':
+ return from + 1;
+ case '\\': {
+ const next1 = text[from + 1];
+ switch (next1) {
+ case 'x':
+ if (isHexaDigit(text[from + 2]) && isHexaDigit(text[from + 3])) {
+ return from + 4;
+ }
+ throw new Error(`Unexpected token '${text.substring(from, from + 4)}' found`);
+ case 'u':
+ if (text[from + 2] === '{') {
+ if (!unicodeMode) {
+ return from + 2;
+ }
+ if (text[from + 4] === '}') {
+ if (isHexaDigit(text[from + 3])) {
+ return from + 5;
+ }
+ throw new Error(`Unexpected token '${text.substring(from, from + 5)}' found`);
+ }
+ if (text[from + 5] === '}') {
+ if (isHexaDigit(text[from + 3]) && isHexaDigit(text[from + 4])) {
+ return from + 6;
+ }
+ throw new Error(`Unexpected token '${text.substring(from, from + 6)}' found`);
+ }
+ if (text[from + 6] === '}') {
+ if (isHexaDigit(text[from + 3]) && isHexaDigit(text[from + 4]) && isHexaDigit(text[from + 5])) {
+ return from + 7;
+ }
+ throw new Error(`Unexpected token '${text.substring(from, from + 7)}' found`);
+ }
+ if (text[from + 7] === '}') {
+ if (isHexaDigit(text[from + 3]) &&
+ isHexaDigit(text[from + 4]) &&
+ isHexaDigit(text[from + 5]) &&
+ isHexaDigit(text[from + 6])) {
+ return from + 8;
+ }
+ throw new Error(`Unexpected token '${text.substring(from, from + 8)}' found`);
+ }
+ if (text[from + 8] === '}' &&
+ isHexaDigit(text[from + 3]) &&
+ isHexaDigit(text[from + 4]) &&
+ isHexaDigit(text[from + 5]) &&
+ isHexaDigit(text[from + 6]) &&
+ isHexaDigit(text[from + 7])) {
+ return from + 9;
+ }
+ throw new Error(`Unexpected token '${text.substring(from, from + 9)}' found`);
+ }
+ if (isHexaDigit(text[from + 2]) &&
+ isHexaDigit(text[from + 3]) &&
+ isHexaDigit(text[from + 4]) &&
+ isHexaDigit(text[from + 5])) {
+ return from + 6;
+ }
+ throw new Error(`Unexpected token '${text.substring(from, from + 6)}' found`);
+ case 'p':
+ case 'P': {
+ if (!unicodeMode) {
+ return from + 2;
+ }
+ let subIndex = from + 2;
+ for (; subIndex < text.length && text[subIndex] !== '}'; subIndex += text[subIndex] === '\\' ? 2 : 1) {
+ }
+ if (text[subIndex] !== '}') {
+ throw new Error(`Invalid \\P definition`);
+ }
+ return subIndex + 1;
+ }
+ case 'k': {
+ let subIndex = from + 2;
+ for (; subIndex < text.length && text[subIndex] !== '>'; ++subIndex) {
+ }
+ if (text[subIndex] !== '>') {
+ if (!unicodeMode) {
+ return from + 2;
+ }
+ throw new Error(`Invalid \\k definition`);
+ }
+ return subIndex + 1;
+ }
+ default: {
+ if (isDigit(next1)) {
+ const maxIndex = unicodeMode ? text.length : Math.min(from + 4, text.length);
+ let subIndex = from + 2;
+ for (; subIndex < maxIndex && isDigit(text[subIndex]); ++subIndex) {
+ }
+ return subIndex;
+ }
+ const charSize = unicodeMode ? charSizeAt(text, from + 1) : 1;
+ return from + charSize + 1;
+ }
+ }
+ }
+ default: {
+ const charSize = unicodeMode ? charSizeAt(text, from) : 1;
+ return from + charSize;
+ }
+ }
+}
+function readFrom(text, from, unicodeMode, mode) {
+ const to = blockEndFrom(text, from, unicodeMode, mode);
+ return text.substring(from, to);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/helpers/SameValueSet.js b/node_modules/fast-check/lib/arbitrary/_internals/helpers/SameValueSet.js
new file mode 100644
index 0000000000000000000000000000000000000000..5f35024bab0c9a0091880d57e630971562ab97b2
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/helpers/SameValueSet.js
@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SameValueSet = void 0;
+const globals_1 = require("../../../utils/globals");
+const safeObjectIs = Object.is;
+class SameValueSet {
+ constructor(selector) {
+ this.selector = selector;
+ this.selectedItemsExceptMinusZero = new globals_1.Set();
+ this.data = [];
+ this.hasMinusZero = false;
+ }
+ tryAdd(value) {
+ const selected = this.selector(value);
+ if (safeObjectIs(selected, -0)) {
+ if (this.hasMinusZero) {
+ return false;
+ }
+ (0, globals_1.safePush)(this.data, value);
+ this.hasMinusZero = true;
+ return true;
+ }
+ const sizeBefore = this.selectedItemsExceptMinusZero.size;
+ (0, globals_1.safeAdd)(this.selectedItemsExceptMinusZero, selected);
+ if (sizeBefore !== this.selectedItemsExceptMinusZero.size) {
+ (0, globals_1.safePush)(this.data, value);
+ return true;
+ }
+ return false;
+ }
+ size() {
+ return this.data.length;
+ }
+ getData() {
+ return this.data;
+ }
+}
+exports.SameValueSet = SameValueSet;
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/helpers/SameValueZeroSet.js b/node_modules/fast-check/lib/arbitrary/_internals/helpers/SameValueZeroSet.js
new file mode 100644
index 0000000000000000000000000000000000000000..ada426611d6c3f9f280b4482229d903f4ca86a20
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/helpers/SameValueZeroSet.js
@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SameValueZeroSet = void 0;
+const globals_1 = require("../../../utils/globals");
+class SameValueZeroSet {
+ constructor(selector) {
+ this.selector = selector;
+ this.selectedItems = new globals_1.Set();
+ this.data = [];
+ }
+ tryAdd(value) {
+ const selected = this.selector(value);
+ const sizeBefore = this.selectedItems.size;
+ (0, globals_1.safeAdd)(this.selectedItems, selected);
+ if (sizeBefore !== this.selectedItems.size) {
+ (0, globals_1.safePush)(this.data, value);
+ return true;
+ }
+ return false;
+ }
+ size() {
+ return this.data.length;
+ }
+ getData() {
+ return this.data;
+ }
+}
+exports.SameValueZeroSet = SameValueZeroSet;
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/helpers/SanitizeRegexAst.js b/node_modules/fast-check/lib/arbitrary/_internals/helpers/SanitizeRegexAst.js
new file mode 100644
index 0000000000000000000000000000000000000000..803c064eab6e6dee998790b35584e1b9429e8a8e
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/helpers/SanitizeRegexAst.js
@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addMissingDotStar = addMissingDotStar;
+const stringify_1 = require("../../../utils/stringify");
+function raiseUnsupportedASTNode(astNode) {
+ return new Error(`Unsupported AST node! Received: ${(0, stringify_1.stringify)(astNode)}`);
+}
+function addMissingDotStarTraversalAddMissing(astNode, isFirst, isLast) {
+ if (!isFirst && !isLast) {
+ return astNode;
+ }
+ const traversalResults = { hasStart: false, hasEnd: false };
+ const revampedNode = addMissingDotStarTraversal(astNode, isFirst, isLast, traversalResults);
+ const missingStart = isFirst && !traversalResults.hasStart;
+ const missingEnd = isLast && !traversalResults.hasEnd;
+ if (!missingStart && !missingEnd) {
+ return revampedNode;
+ }
+ const expressions = [];
+ if (missingStart) {
+ expressions.push({ type: 'Assertion', kind: '^' });
+ expressions.push({
+ type: 'Repetition',
+ quantifier: { type: 'Quantifier', kind: '*', greedy: true },
+ expression: { type: 'Char', kind: 'meta', symbol: '.', value: '.', codePoint: Number.NaN },
+ });
+ }
+ expressions.push(revampedNode);
+ if (missingEnd) {
+ expressions.push({
+ type: 'Repetition',
+ quantifier: { type: 'Quantifier', kind: '*', greedy: true },
+ expression: { type: 'Char', kind: 'meta', symbol: '.', value: '.', codePoint: Number.NaN },
+ });
+ expressions.push({ type: 'Assertion', kind: '$' });
+ }
+ return { type: 'Group', capturing: false, expression: { type: 'Alternative', expressions } };
+}
+function addMissingDotStarTraversal(astNode, isFirst, isLast, traversalResults) {
+ switch (astNode.type) {
+ case 'Char':
+ return astNode;
+ case 'Repetition':
+ return astNode;
+ case 'Quantifier':
+ throw new Error(`Wrongly defined AST tree, Quantifier nodes not supposed to be scanned!`);
+ case 'Alternative':
+ traversalResults.hasStart = true;
+ traversalResults.hasEnd = true;
+ return Object.assign(Object.assign({}, astNode), { expressions: astNode.expressions.map((node, index) => addMissingDotStarTraversalAddMissing(node, isFirst && index === 0, isLast && index === astNode.expressions.length - 1)) });
+ case 'CharacterClass':
+ return astNode;
+ case 'ClassRange':
+ return astNode;
+ case 'Group': {
+ return Object.assign(Object.assign({}, astNode), { expression: addMissingDotStarTraversal(astNode.expression, isFirst, isLast, traversalResults) });
+ }
+ case 'Disjunction': {
+ traversalResults.hasStart = true;
+ traversalResults.hasEnd = true;
+ return Object.assign(Object.assign({}, astNode), { left: astNode.left !== null ? addMissingDotStarTraversalAddMissing(astNode.left, isFirst, isLast) : null, right: astNode.right !== null ? addMissingDotStarTraversalAddMissing(astNode.right, isFirst, isLast) : null });
+ }
+ case 'Assertion': {
+ if (astNode.kind === '^' || astNode.kind === 'Lookahead') {
+ traversalResults.hasStart = true;
+ return astNode;
+ }
+ else if (astNode.kind === '$' || astNode.kind === 'Lookbehind') {
+ traversalResults.hasEnd = true;
+ return astNode;
+ }
+ else {
+ throw new Error(`Assertions of kind ${astNode.kind} not implemented yet!`);
+ }
+ }
+ case 'Backreference':
+ return astNode;
+ default:
+ throw raiseUnsupportedASTNode(astNode);
+ }
+}
+function addMissingDotStar(astNode) {
+ return addMissingDotStarTraversalAddMissing(astNode, true, true);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/helpers/ShrinkBigInt.js b/node_modules/fast-check/lib/arbitrary/_internals/helpers/ShrinkBigInt.js
new file mode 100644
index 0000000000000000000000000000000000000000..54826deacbd47be61d1a25f7e299960677c06048
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/helpers/ShrinkBigInt.js
@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shrinkBigInt = shrinkBigInt;
+const Stream_1 = require("../../../stream/Stream");
+const Value_1 = require("../../../check/arbitrary/definition/Value");
+const globals_1 = require("../../../utils/globals");
+function halveBigInt(n) {
+ return n / (0, globals_1.BigInt)(2);
+}
+function shrinkBigInt(current, target, tryTargetAsap) {
+ const realGap = current - target;
+ function* shrinkDecr() {
+ let previous = tryTargetAsap ? undefined : target;
+ const gap = tryTargetAsap ? realGap : halveBigInt(realGap);
+ for (let toremove = gap; toremove > 0; toremove = halveBigInt(toremove)) {
+ const next = current - toremove;
+ yield new Value_1.Value(next, previous);
+ previous = next;
+ }
+ }
+ function* shrinkIncr() {
+ let previous = tryTargetAsap ? undefined : target;
+ const gap = tryTargetAsap ? realGap : halveBigInt(realGap);
+ for (let toremove = gap; toremove < 0; toremove = halveBigInt(toremove)) {
+ const next = current - toremove;
+ yield new Value_1.Value(next, previous);
+ previous = next;
+ }
+ }
+ return realGap > 0 ? (0, Stream_1.stream)(shrinkDecr()) : (0, Stream_1.stream)(shrinkIncr());
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/helpers/ShrinkInteger.js b/node_modules/fast-check/lib/arbitrary/_internals/helpers/ShrinkInteger.js
new file mode 100644
index 0000000000000000000000000000000000000000..4bc101325e5eae640a1b5b148574c42faef7429d
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/helpers/ShrinkInteger.js
@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shrinkInteger = shrinkInteger;
+const Value_1 = require("../../../check/arbitrary/definition/Value");
+const Stream_1 = require("../../../stream/Stream");
+const safeMathCeil = Math.ceil;
+const safeMathFloor = Math.floor;
+function halvePosInteger(n) {
+ return safeMathFloor(n / 2);
+}
+function halveNegInteger(n) {
+ return safeMathCeil(n / 2);
+}
+function shrinkInteger(current, target, tryTargetAsap) {
+ const realGap = current - target;
+ function* shrinkDecr() {
+ let previous = tryTargetAsap ? undefined : target;
+ const gap = tryTargetAsap ? realGap : halvePosInteger(realGap);
+ for (let toremove = gap; toremove > 0; toremove = halvePosInteger(toremove)) {
+ const next = toremove === realGap ? target : current - toremove;
+ yield new Value_1.Value(next, previous);
+ previous = next;
+ }
+ }
+ function* shrinkIncr() {
+ let previous = tryTargetAsap ? undefined : target;
+ const gap = tryTargetAsap ? realGap : halveNegInteger(realGap);
+ for (let toremove = gap; toremove < 0; toremove = halveNegInteger(toremove)) {
+ const next = toremove === realGap ? target : current - toremove;
+ yield new Value_1.Value(next, previous);
+ previous = next;
+ }
+ }
+ return realGap > 0 ? (0, Stream_1.stream)(shrinkDecr()) : (0, Stream_1.stream)(shrinkIncr());
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/helpers/SlicesForStringBuilder.js b/node_modules/fast-check/lib/arbitrary/_internals/helpers/SlicesForStringBuilder.js
new file mode 100644
index 0000000000000000000000000000000000000000..48717653bf41d22bd40d6d1a6aa4ef1a13a9cbd6
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/helpers/SlicesForStringBuilder.js
@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSlicesForStringLegacy = createSlicesForStringLegacy;
+exports.createSlicesForString = createSlicesForString;
+const globals_1 = require("../../../utils/globals");
+const PatternsToString_1 = require("../mappers/PatternsToString");
+const MaxLengthFromMinLength_1 = require("./MaxLengthFromMinLength");
+const TokenizeString_1 = require("./TokenizeString");
+const dangerousStrings = [
+ '__defineGetter__',
+ '__defineSetter__',
+ '__lookupGetter__',
+ '__lookupSetter__',
+ '__proto__',
+ 'constructor',
+ 'hasOwnProperty',
+ 'isPrototypeOf',
+ 'propertyIsEnumerable',
+ 'toLocaleString',
+ 'toString',
+ 'valueOf',
+ 'apply',
+ 'arguments',
+ 'bind',
+ 'call',
+ 'caller',
+ 'length',
+ 'name',
+ 'prototype',
+ 'key',
+ 'ref',
+];
+function computeCandidateStringLegacy(dangerous, charArbitrary, stringSplitter) {
+ let candidate;
+ try {
+ candidate = stringSplitter(dangerous);
+ }
+ catch (err) {
+ return undefined;
+ }
+ for (const entry of candidate) {
+ if (!charArbitrary.canShrinkWithoutContext(entry)) {
+ return undefined;
+ }
+ }
+ return candidate;
+}
+function createSlicesForStringLegacy(charArbitrary, stringSplitter) {
+ const slicesForString = [];
+ for (const dangerous of dangerousStrings) {
+ const candidate = computeCandidateStringLegacy(dangerous, charArbitrary, stringSplitter);
+ if (candidate !== undefined) {
+ (0, globals_1.safePush)(slicesForString, candidate);
+ }
+ }
+ return slicesForString;
+}
+const slicesPerArbitrary = new WeakMap();
+function createSlicesForStringNoConstraints(charArbitrary) {
+ const slicesForString = [];
+ for (const dangerous of dangerousStrings) {
+ const candidate = (0, TokenizeString_1.tokenizeString)(charArbitrary, dangerous, 0, MaxLengthFromMinLength_1.MaxLengthUpperBound);
+ if (candidate !== undefined) {
+ (0, globals_1.safePush)(slicesForString, candidate);
+ }
+ }
+ return slicesForString;
+}
+function createSlicesForString(charArbitrary, constraints) {
+ let slices = (0, globals_1.safeGet)(slicesPerArbitrary, charArbitrary);
+ if (slices === undefined) {
+ slices = createSlicesForStringNoConstraints(charArbitrary);
+ (0, globals_1.safeSet)(slicesPerArbitrary, charArbitrary, slices);
+ }
+ const slicesForConstraints = [];
+ for (const slice of slices) {
+ if ((0, PatternsToString_1.patternsToStringUnmapperIsValidLength)(slice, constraints)) {
+ (0, globals_1.safePush)(slicesForConstraints, slice);
+ }
+ }
+ return slicesForConstraints;
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/helpers/StrictlyEqualSet.js b/node_modules/fast-check/lib/arbitrary/_internals/helpers/StrictlyEqualSet.js
new file mode 100644
index 0000000000000000000000000000000000000000..02fbb8888e411abbbf99c0d7ab873d8ffbd7107b
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/helpers/StrictlyEqualSet.js
@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StrictlyEqualSet = void 0;
+const globals_1 = require("../../../utils/globals");
+const safeNumberIsNaN = Number.isNaN;
+class StrictlyEqualSet {
+ constructor(selector) {
+ this.selector = selector;
+ this.selectedItemsExceptNaN = new globals_1.Set();
+ this.data = [];
+ }
+ tryAdd(value) {
+ const selected = this.selector(value);
+ if (safeNumberIsNaN(selected)) {
+ (0, globals_1.safePush)(this.data, value);
+ return true;
+ }
+ const sizeBefore = this.selectedItemsExceptNaN.size;
+ (0, globals_1.safeAdd)(this.selectedItemsExceptNaN, selected);
+ if (sizeBefore !== this.selectedItemsExceptNaN.size) {
+ (0, globals_1.safePush)(this.data, value);
+ return true;
+ }
+ return false;
+ }
+ size() {
+ return this.data.length;
+ }
+ getData() {
+ return this.data;
+ }
+}
+exports.StrictlyEqualSet = StrictlyEqualSet;
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/helpers/TextEscaper.js b/node_modules/fast-check/lib/arbitrary/_internals/helpers/TextEscaper.js
new file mode 100644
index 0000000000000000000000000000000000000000..e83dfd2f2641ed3513c4170510d012bad848538d
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/helpers/TextEscaper.js
@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.escapeForTemplateString = escapeForTemplateString;
+exports.escapeForMultilineComments = escapeForMultilineComments;
+function escapeForTemplateString(originalText) {
+ return originalText.replace(/([$`\\])/g, '\\$1').replace(/\r/g, '\\r');
+}
+function escapeForMultilineComments(originalText) {
+ return originalText.replace(/\*\//g, '*\\/');
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/helpers/ToggleFlags.js b/node_modules/fast-check/lib/arbitrary/_internals/helpers/ToggleFlags.js
new file mode 100644
index 0000000000000000000000000000000000000000..2866490ab7698ec44b2e493446e78e30b00d93af
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/helpers/ToggleFlags.js
@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.countToggledBits = countToggledBits;
+exports.computeNextFlags = computeNextFlags;
+exports.computeTogglePositions = computeTogglePositions;
+exports.computeFlagsFromChars = computeFlagsFromChars;
+exports.applyFlagsOnChars = applyFlagsOnChars;
+const globals_1 = require("../../../utils/globals");
+function countToggledBits(n) {
+ let count = 0;
+ while (n > (0, globals_1.BigInt)(0)) {
+ if (n & (0, globals_1.BigInt)(1))
+ ++count;
+ n >>= (0, globals_1.BigInt)(1);
+ }
+ return count;
+}
+function computeNextFlags(flags, nextSize) {
+ const allowedMask = ((0, globals_1.BigInt)(1) << (0, globals_1.BigInt)(nextSize)) - (0, globals_1.BigInt)(1);
+ const preservedFlags = flags & allowedMask;
+ let numMissingFlags = countToggledBits(flags - preservedFlags);
+ let nFlags = preservedFlags;
+ for (let mask = (0, globals_1.BigInt)(1); mask <= allowedMask && numMissingFlags !== 0; mask <<= (0, globals_1.BigInt)(1)) {
+ if (!(nFlags & mask)) {
+ nFlags |= mask;
+ --numMissingFlags;
+ }
+ }
+ return nFlags;
+}
+function computeTogglePositions(chars, toggleCase) {
+ const positions = [];
+ for (let idx = chars.length - 1; idx !== -1; --idx) {
+ if (toggleCase(chars[idx]) !== chars[idx])
+ (0, globals_1.safePush)(positions, idx);
+ }
+ return positions;
+}
+function computeFlagsFromChars(untoggledChars, toggledChars, togglePositions) {
+ let flags = (0, globals_1.BigInt)(0);
+ for (let idx = 0, mask = (0, globals_1.BigInt)(1); idx !== togglePositions.length; ++idx, mask <<= (0, globals_1.BigInt)(1)) {
+ if (untoggledChars[togglePositions[idx]] !== toggledChars[togglePositions[idx]]) {
+ flags |= mask;
+ }
+ }
+ return flags;
+}
+function applyFlagsOnChars(chars, flags, togglePositions, toggleCase) {
+ for (let idx = 0, mask = (0, globals_1.BigInt)(1); idx !== togglePositions.length; ++idx, mask <<= (0, globals_1.BigInt)(1)) {
+ if (flags & mask)
+ chars[togglePositions[idx]] = toggleCase(chars[togglePositions[idx]]);
+ }
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/helpers/TokenizeRegex.js b/node_modules/fast-check/lib/arbitrary/_internals/helpers/TokenizeRegex.js
new file mode 100644
index 0000000000000000000000000000000000000000..efb2d416d31d3ae76bdcac643bd0679ad6d2c7e7
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/helpers/TokenizeRegex.js
@@ -0,0 +1,323 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tokenizeRegex = tokenizeRegex;
+const globals_1 = require("../../../utils/globals");
+const ReadRegex_1 = require("./ReadRegex");
+const safeStringFromCodePoint = String.fromCodePoint;
+function safePop(tokens) {
+ const previous = tokens.pop();
+ if (previous === undefined) {
+ throw new Error('Unable to extract token preceeding the currently parsed one');
+ }
+ return previous;
+}
+function isDigit(char) {
+ return char >= '0' && char <= '9';
+}
+function simpleChar(char, escaped) {
+ return {
+ type: 'Char',
+ kind: 'simple',
+ symbol: char,
+ value: char,
+ codePoint: char.codePointAt(0) || -1,
+ escaped,
+ };
+}
+function metaEscapedChar(block, symbol) {
+ return {
+ type: 'Char',
+ kind: 'meta',
+ symbol,
+ value: block,
+ codePoint: symbol.codePointAt(0) || -1,
+ };
+}
+function toSingleToken(tokens, allowEmpty) {
+ if (tokens.length > 1) {
+ return {
+ type: 'Alternative',
+ expressions: tokens,
+ };
+ }
+ if (!allowEmpty && tokens.length === 0) {
+ throw new Error(`Unsupported no token`);
+ }
+ return tokens[0];
+}
+function blockToCharToken(block) {
+ if (block[0] === '\\') {
+ const next = block[1];
+ switch (next) {
+ case 'x': {
+ const allDigits = block.substring(2);
+ const codePoint = Number.parseInt(allDigits, 16);
+ const symbol = safeStringFromCodePoint(codePoint);
+ return { type: 'Char', kind: 'hex', symbol, value: block, codePoint };
+ }
+ case 'u': {
+ if (block === '\\u') {
+ return simpleChar('u', true);
+ }
+ const allDigits = block[2] === '{' ? block.substring(3, block.length - 1) : block.substring(2);
+ const codePoint = Number.parseInt(allDigits, 16);
+ const symbol = safeStringFromCodePoint(codePoint);
+ return { type: 'Char', kind: 'unicode', symbol, value: block, codePoint };
+ }
+ case '0': {
+ return metaEscapedChar(block, '\0');
+ }
+ case 'n': {
+ return metaEscapedChar(block, '\n');
+ }
+ case 'f': {
+ return metaEscapedChar(block, '\f');
+ }
+ case 'r': {
+ return metaEscapedChar(block, '\r');
+ }
+ case 't': {
+ return metaEscapedChar(block, '\t');
+ }
+ case 'v': {
+ return metaEscapedChar(block, '\v');
+ }
+ case 'w':
+ case 'W':
+ case 'd':
+ case 'D':
+ case 's':
+ case 'S':
+ case 'b':
+ case 'B': {
+ return { type: 'Char', kind: 'meta', symbol: undefined, value: block, codePoint: Number.NaN };
+ }
+ default: {
+ if (isDigit(next)) {
+ const allDigits = block.substring(1);
+ const codePoint = Number(allDigits);
+ const symbol = safeStringFromCodePoint(codePoint);
+ return { type: 'Char', kind: 'decimal', symbol, value: block, codePoint };
+ }
+ if (block.length > 2 && (next === 'p' || next === 'P')) {
+ throw new Error(`UnicodeProperty not implemented yet!`);
+ }
+ const char = block.substring(1);
+ return simpleChar(char, true);
+ }
+ }
+ }
+ return simpleChar(block);
+}
+function pushTokens(tokens, regexSource, unicodeMode, groups) {
+ let disjunctions = null;
+ for (let index = 0, block = (0, ReadRegex_1.readFrom)(regexSource, index, unicodeMode, ReadRegex_1.TokenizerBlockMode.Full); index !== regexSource.length; index += block.length, block = (0, ReadRegex_1.readFrom)(regexSource, index, unicodeMode, ReadRegex_1.TokenizerBlockMode.Full)) {
+ const firstInBlock = block[0];
+ switch (firstInBlock) {
+ case '|': {
+ if (disjunctions === null) {
+ disjunctions = [];
+ }
+ disjunctions.push(toSingleToken(tokens.splice(0), true) || null);
+ break;
+ }
+ case '.': {
+ tokens.push({ type: 'Char', kind: 'meta', symbol: block, value: block, codePoint: Number.NaN });
+ break;
+ }
+ case '*':
+ case '+': {
+ const previous = safePop(tokens);
+ tokens.push({
+ type: 'Repetition',
+ expression: previous,
+ quantifier: { type: 'Quantifier', kind: firstInBlock, greedy: true },
+ });
+ break;
+ }
+ case '?': {
+ const previous = safePop(tokens);
+ if (previous.type === 'Repetition') {
+ previous.quantifier.greedy = false;
+ tokens.push(previous);
+ }
+ else {
+ tokens.push({
+ type: 'Repetition',
+ expression: previous,
+ quantifier: { type: 'Quantifier', kind: firstInBlock, greedy: true },
+ });
+ }
+ break;
+ }
+ case '{': {
+ if (block === '{') {
+ tokens.push(simpleChar(block));
+ break;
+ }
+ const previous = safePop(tokens);
+ const quantifierText = block.substring(1, block.length - 1);
+ const quantifierTokens = quantifierText.split(',');
+ const from = Number(quantifierTokens[0]);
+ const to = quantifierTokens.length === 1
+ ? from
+ : quantifierTokens[1].length !== 0
+ ? Number(quantifierTokens[1])
+ : undefined;
+ tokens.push({
+ type: 'Repetition',
+ expression: previous,
+ quantifier: { type: 'Quantifier', kind: 'Range', greedy: true, from, to },
+ });
+ break;
+ }
+ case '[': {
+ const blockContent = block.substring(1, block.length - 1);
+ const subTokens = [];
+ let negative = undefined;
+ let previousWasSimpleDash = false;
+ for (let subIndex = 0, subBlock = (0, ReadRegex_1.readFrom)(blockContent, subIndex, unicodeMode, ReadRegex_1.TokenizerBlockMode.Character); subIndex !== blockContent.length; subIndex += subBlock.length,
+ subBlock = (0, ReadRegex_1.readFrom)(blockContent, subIndex, unicodeMode, ReadRegex_1.TokenizerBlockMode.Character)) {
+ if (subIndex === 0 && subBlock === '^') {
+ negative = true;
+ continue;
+ }
+ const newToken = blockToCharToken(subBlock);
+ if (subBlock === '-') {
+ subTokens.push(newToken);
+ previousWasSimpleDash = true;
+ }
+ else {
+ const operand1Token = subTokens.length >= 2 ? subTokens[subTokens.length - 2] : undefined;
+ if (previousWasSimpleDash && operand1Token !== undefined && operand1Token.type === 'Char') {
+ subTokens.pop();
+ subTokens.pop();
+ subTokens.push({ type: 'ClassRange', from: operand1Token, to: newToken });
+ }
+ else {
+ subTokens.push(newToken);
+ }
+ previousWasSimpleDash = false;
+ }
+ }
+ tokens.push({ type: 'CharacterClass', expressions: subTokens, negative });
+ break;
+ }
+ case '(': {
+ const blockContent = block.substring(1, block.length - 1);
+ const subTokens = [];
+ if (blockContent[0] === '?') {
+ if (blockContent[1] === ':') {
+ pushTokens(subTokens, blockContent.substring(2), unicodeMode, groups);
+ tokens.push({
+ type: 'Group',
+ capturing: false,
+ expression: toSingleToken(subTokens),
+ });
+ }
+ else if (blockContent[1] === '=' || blockContent[1] === '!') {
+ pushTokens(subTokens, blockContent.substring(2), unicodeMode, groups);
+ tokens.push({
+ type: 'Assertion',
+ kind: 'Lookahead',
+ negative: blockContent[1] === '!' ? true : undefined,
+ assertion: toSingleToken(subTokens),
+ });
+ }
+ else if (blockContent[1] === '<' && (blockContent[2] === '=' || blockContent[2] === '!')) {
+ pushTokens(subTokens, blockContent.substring(3), unicodeMode, groups);
+ tokens.push({
+ type: 'Assertion',
+ kind: 'Lookbehind',
+ negative: blockContent[2] === '!' ? true : undefined,
+ assertion: toSingleToken(subTokens),
+ });
+ }
+ else {
+ const chunks = blockContent.split('>');
+ if (chunks.length < 2 || chunks[0][1] !== '<') {
+ throw new Error(`Unsupported regex content found at ${JSON.stringify(block)}`);
+ }
+ const groupIndex = ++groups.lastIndex;
+ const nameRaw = chunks[0].substring(2);
+ groups.named.set(nameRaw, groupIndex);
+ pushTokens(subTokens, chunks.slice(1).join('>'), unicodeMode, groups);
+ tokens.push({
+ type: 'Group',
+ capturing: true,
+ nameRaw,
+ name: nameRaw,
+ number: groupIndex,
+ expression: toSingleToken(subTokens),
+ });
+ }
+ }
+ else {
+ const groupIndex = ++groups.lastIndex;
+ pushTokens(subTokens, blockContent, unicodeMode, groups);
+ tokens.push({
+ type: 'Group',
+ capturing: true,
+ number: groupIndex,
+ expression: toSingleToken(subTokens),
+ });
+ }
+ break;
+ }
+ default: {
+ if (block === '^') {
+ tokens.push({ type: 'Assertion', kind: block });
+ }
+ else if (block === '$') {
+ tokens.push({ type: 'Assertion', kind: block });
+ }
+ else if (block[0] === '\\' && isDigit(block[1])) {
+ const reference = Number(block.substring(1));
+ if (unicodeMode || reference <= groups.lastIndex) {
+ tokens.push({ type: 'Backreference', kind: 'number', number: reference, reference });
+ }
+ else {
+ tokens.push(blockToCharToken(block));
+ }
+ }
+ else if (block[0] === '\\' && block[1] === 'k' && block.length !== 2) {
+ const referenceRaw = block.substring(3, block.length - 1);
+ tokens.push({
+ type: 'Backreference',
+ kind: 'name',
+ number: groups.named.get(referenceRaw) || 0,
+ referenceRaw,
+ reference: referenceRaw,
+ });
+ }
+ else {
+ tokens.push(blockToCharToken(block));
+ }
+ break;
+ }
+ }
+ }
+ if (disjunctions !== null) {
+ disjunctions.push(toSingleToken(tokens.splice(0), true) || null);
+ let currentDisjunction = {
+ type: 'Disjunction',
+ left: disjunctions[0],
+ right: disjunctions[1],
+ };
+ for (let index = 2; index < disjunctions.length; ++index) {
+ currentDisjunction = {
+ type: 'Disjunction',
+ left: currentDisjunction,
+ right: disjunctions[index],
+ };
+ }
+ tokens.push(currentDisjunction);
+ }
+}
+function tokenizeRegex(regex) {
+ const unicodeMode = (0, globals_1.safeIndexOf)([...regex.flags], 'u') !== -1;
+ const regexSource = regex.source;
+ const tokens = [];
+ pushTokens(tokens, regexSource, unicodeMode, { lastIndex: 0, named: new Map() });
+ return toSingleToken(tokens);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/helpers/TokenizeString.js b/node_modules/fast-check/lib/arbitrary/_internals/helpers/TokenizeString.js
new file mode 100644
index 0000000000000000000000000000000000000000..07df221dc6603ab606dbd151bdee60b0edfee197
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/helpers/TokenizeString.js
@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tokenizeString = tokenizeString;
+const globals_1 = require("../../../utils/globals");
+function tokenizeString(patternsArb, value, minLength, maxLength) {
+ if (value.length === 0) {
+ if (minLength > 0) {
+ return undefined;
+ }
+ return [];
+ }
+ if (maxLength <= 0) {
+ return undefined;
+ }
+ const stack = [{ endIndexChunks: 0, nextStartIndex: 1, chunks: [] }];
+ while (stack.length > 0) {
+ const last = (0, globals_1.safePop)(stack);
+ for (let index = last.nextStartIndex; index <= value.length; ++index) {
+ const chunk = (0, globals_1.safeSubstring)(value, last.endIndexChunks, index);
+ if (patternsArb.canShrinkWithoutContext(chunk)) {
+ const newChunks = [...last.chunks, chunk];
+ if (index === value.length) {
+ if (newChunks.length < minLength) {
+ break;
+ }
+ return newChunks;
+ }
+ (0, globals_1.safePush)(stack, { endIndexChunks: last.endIndexChunks, nextStartIndex: index + 1, chunks: last.chunks });
+ if (newChunks.length < maxLength) {
+ (0, globals_1.safePush)(stack, { endIndexChunks: index, nextStartIndex: index + 1, chunks: newChunks });
+ }
+ break;
+ }
+ }
+ }
+ return undefined;
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/helpers/ZipIterableIterators.js b/node_modules/fast-check/lib/arbitrary/_internals/helpers/ZipIterableIterators.js
new file mode 100644
index 0000000000000000000000000000000000000000..81fe36ffbed89e2b6941ab4cd201a7645c661583
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/helpers/ZipIterableIterators.js
@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zipIterableIterators = zipIterableIterators;
+function initZippedValues(its) {
+ const vs = [];
+ for (let index = 0; index !== its.length; ++index) {
+ vs.push(its[index].next());
+ }
+ return vs;
+}
+function nextZippedValues(its, vs) {
+ for (let index = 0; index !== its.length; ++index) {
+ vs[index] = its[index].next();
+ }
+}
+function isDoneZippedValues(vs) {
+ for (let index = 0; index !== vs.length; ++index) {
+ if (vs[index].done) {
+ return true;
+ }
+ }
+ return false;
+}
+function* zipIterableIterators(...its) {
+ const vs = initZippedValues(its);
+ while (!isDoneZippedValues(vs)) {
+ yield vs.map((v) => v.value);
+ nextZippedValues(its, vs);
+ }
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/implementations/NoopSlicedGenerator.js b/node_modules/fast-check/lib/arbitrary/_internals/implementations/NoopSlicedGenerator.js
new file mode 100644
index 0000000000000000000000000000000000000000..9a23026f0a38b44c71da483549e6a3e0cd742782
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/implementations/NoopSlicedGenerator.js
@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoopSlicedGenerator = void 0;
+class NoopSlicedGenerator {
+ constructor(arb, mrng, biasFactor) {
+ this.arb = arb;
+ this.mrng = mrng;
+ this.biasFactor = biasFactor;
+ }
+ attemptExact() {
+ return;
+ }
+ next() {
+ return this.arb.generate(this.mrng, this.biasFactor);
+ }
+}
+exports.NoopSlicedGenerator = NoopSlicedGenerator;
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/implementations/SchedulerImplem.js b/node_modules/fast-check/lib/arbitrary/_internals/implementations/SchedulerImplem.js
new file mode 100644
index 0000000000000000000000000000000000000000..497a7bc1c980f1991db7c53937512cd52f9d47aa
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/implementations/SchedulerImplem.js
@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchedulerImplem = void 0;
+const TextEscaper_1 = require("../helpers/TextEscaper");
+const symbols_1 = require("../../../check/symbols");
+const stringify_1 = require("../../../utils/stringify");
+const defaultSchedulerAct = (f) => f();
+class SchedulerImplem {
+ constructor(act, taskSelector) {
+ this.act = act;
+ this.taskSelector = taskSelector;
+ this.lastTaskId = 0;
+ this.sourceTaskSelector = taskSelector.clone();
+ this.scheduledTasks = [];
+ this.triggeredTasks = [];
+ this.scheduledWatchers = [];
+ }
+ static buildLog(reportItem) {
+ return `[task\${${reportItem.taskId}}] ${reportItem.label.length !== 0 ? `${reportItem.schedulingType}::${reportItem.label}` : reportItem.schedulingType} ${reportItem.status}${reportItem.outputValue !== undefined ? ` with value ${(0, TextEscaper_1.escapeForTemplateString)(reportItem.outputValue)}` : ''}`;
+ }
+ log(schedulingType, taskId, label, metadata, status, data) {
+ this.triggeredTasks.push({
+ status,
+ schedulingType,
+ taskId,
+ label,
+ metadata,
+ outputValue: data !== undefined ? (0, stringify_1.stringify)(data) : undefined,
+ });
+ }
+ scheduleInternal(schedulingType, label, task, metadata, customAct, thenTaskToBeAwaited) {
+ let trigger = null;
+ const taskId = ++this.lastTaskId;
+ const scheduledPromise = new Promise((resolve, reject) => {
+ trigger = () => {
+ (thenTaskToBeAwaited ? task.then(() => thenTaskToBeAwaited()) : task).then((data) => {
+ this.log(schedulingType, taskId, label, metadata, 'resolved', data);
+ return resolve(data);
+ }, (err) => {
+ this.log(schedulingType, taskId, label, metadata, 'rejected', err);
+ return reject(err);
+ });
+ };
+ });
+ this.scheduledTasks.push({
+ original: task,
+ scheduled: scheduledPromise,
+ trigger: trigger,
+ schedulingType,
+ taskId,
+ label,
+ metadata,
+ customAct,
+ });
+ if (this.scheduledWatchers.length !== 0) {
+ this.scheduledWatchers[0]();
+ }
+ return scheduledPromise;
+ }
+ schedule(task, label, metadata, customAct) {
+ return this.scheduleInternal('promise', label || '', task, metadata, customAct || defaultSchedulerAct);
+ }
+ scheduleFunction(asyncFunction, customAct) {
+ return (...args) => this.scheduleInternal('function', `${asyncFunction.name}(${args.map(stringify_1.stringify).join(',')})`, asyncFunction(...args), undefined, customAct || defaultSchedulerAct);
+ }
+ scheduleSequence(sequenceBuilders, customAct) {
+ const status = { done: false, faulty: false };
+ const dummyResolvedPromise = { then: (f) => f() };
+ let resolveSequenceTask = () => { };
+ const sequenceTask = new Promise((resolve) => (resolveSequenceTask = resolve));
+ sequenceBuilders
+ .reduce((previouslyScheduled, item) => {
+ const [builder, label, metadata] = typeof item === 'function' ? [item, item.name, undefined] : [item.builder, item.label, item.metadata];
+ return previouslyScheduled.then(() => {
+ const scheduled = this.scheduleInternal('sequence', label, dummyResolvedPromise, metadata, customAct || defaultSchedulerAct, () => builder());
+ scheduled.catch(() => {
+ status.faulty = true;
+ resolveSequenceTask();
+ });
+ return scheduled;
+ });
+ }, dummyResolvedPromise)
+ .then(() => {
+ status.done = true;
+ resolveSequenceTask();
+ }, () => {
+ });
+ return Object.assign(status, {
+ task: Promise.resolve(sequenceTask).then(() => {
+ return { done: status.done, faulty: status.faulty };
+ }),
+ });
+ }
+ count() {
+ return this.scheduledTasks.length;
+ }
+ internalWaitOne() {
+ if (this.scheduledTasks.length === 0) {
+ throw new Error('No task scheduled');
+ }
+ const taskIndex = this.taskSelector.nextTaskIndex(this.scheduledTasks);
+ const [scheduledTask] = this.scheduledTasks.splice(taskIndex, 1);
+ return scheduledTask.customAct(async () => {
+ scheduledTask.trigger();
+ try {
+ await scheduledTask.scheduled;
+ }
+ catch (_err) {
+ }
+ });
+ }
+ async waitOne(customAct) {
+ const waitAct = customAct || defaultSchedulerAct;
+ await this.act(() => waitAct(async () => await this.internalWaitOne()));
+ }
+ async waitAll(customAct) {
+ while (this.scheduledTasks.length > 0) {
+ await this.waitOne(customAct);
+ }
+ }
+ async waitFor(unscheduledTask, customAct) {
+ let taskResolved = false;
+ let awaiterPromise = null;
+ const awaiter = async () => {
+ while (!taskResolved && this.scheduledTasks.length > 0) {
+ await this.waitOne(customAct);
+ }
+ awaiterPromise = null;
+ };
+ const handleNotified = () => {
+ if (awaiterPromise !== null) {
+ return;
+ }
+ awaiterPromise = Promise.resolve().then(awaiter);
+ };
+ const clearAndReplaceWatcher = () => {
+ const handleNotifiedIndex = this.scheduledWatchers.indexOf(handleNotified);
+ if (handleNotifiedIndex !== -1) {
+ this.scheduledWatchers.splice(handleNotifiedIndex, 1);
+ }
+ if (handleNotifiedIndex === 0 && this.scheduledWatchers.length !== 0) {
+ this.scheduledWatchers[0]();
+ }
+ };
+ const rewrappedTask = unscheduledTask.then((ret) => {
+ taskResolved = true;
+ if (awaiterPromise === null) {
+ clearAndReplaceWatcher();
+ return ret;
+ }
+ return awaiterPromise.then(() => {
+ clearAndReplaceWatcher();
+ return ret;
+ });
+ }, (err) => {
+ taskResolved = true;
+ if (awaiterPromise === null) {
+ clearAndReplaceWatcher();
+ throw err;
+ }
+ return awaiterPromise.then(() => {
+ clearAndReplaceWatcher();
+ throw err;
+ });
+ });
+ if (this.scheduledTasks.length > 0 && this.scheduledWatchers.length === 0) {
+ handleNotified();
+ }
+ this.scheduledWatchers.push(handleNotified);
+ return rewrappedTask;
+ }
+ report() {
+ return [
+ ...this.triggeredTasks,
+ ...this.scheduledTasks.map((t) => ({
+ status: 'pending',
+ schedulingType: t.schedulingType,
+ taskId: t.taskId,
+ label: t.label,
+ metadata: t.metadata,
+ })),
+ ];
+ }
+ toString() {
+ return ('schedulerFor()`\n' +
+ this.report()
+ .map(SchedulerImplem.buildLog)
+ .map((log) => `-> ${log}`)
+ .join('\n') +
+ '`');
+ }
+ [symbols_1.cloneMethod]() {
+ return new SchedulerImplem(this.act, this.sourceTaskSelector);
+ }
+}
+exports.SchedulerImplem = SchedulerImplem;
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/implementations/SlicedBasedGenerator.js b/node_modules/fast-check/lib/arbitrary/_internals/implementations/SlicedBasedGenerator.js
new file mode 100644
index 0000000000000000000000000000000000000000..160d2c4210a23924d03df2c20eb0d9a82c099aaf
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/implementations/SlicedBasedGenerator.js
@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlicedBasedGenerator = void 0;
+const Value_1 = require("../../../check/arbitrary/definition/Value");
+const globals_1 = require("../../../utils/globals");
+const safeMathMin = Math.min;
+const safeMathMax = Math.max;
+class SlicedBasedGenerator {
+ constructor(arb, mrng, slices, biasFactor) {
+ this.arb = arb;
+ this.mrng = mrng;
+ this.slices = slices;
+ this.biasFactor = biasFactor;
+ this.activeSliceIndex = 0;
+ this.nextIndexInSlice = 0;
+ this.lastIndexInSlice = -1;
+ }
+ attemptExact(targetLength) {
+ if (targetLength !== 0 && this.mrng.nextInt(1, this.biasFactor) === 1) {
+ const eligibleIndices = [];
+ for (let index = 0; index !== this.slices.length; ++index) {
+ const slice = this.slices[index];
+ if (slice.length === targetLength) {
+ (0, globals_1.safePush)(eligibleIndices, index);
+ }
+ }
+ if (eligibleIndices.length === 0) {
+ return;
+ }
+ this.activeSliceIndex = eligibleIndices[this.mrng.nextInt(0, eligibleIndices.length - 1)];
+ this.nextIndexInSlice = 0;
+ this.lastIndexInSlice = targetLength - 1;
+ }
+ }
+ next() {
+ if (this.nextIndexInSlice <= this.lastIndexInSlice) {
+ return new Value_1.Value(this.slices[this.activeSliceIndex][this.nextIndexInSlice++], undefined);
+ }
+ if (this.mrng.nextInt(1, this.biasFactor) !== 1) {
+ return this.arb.generate(this.mrng, this.biasFactor);
+ }
+ this.activeSliceIndex = this.mrng.nextInt(0, this.slices.length - 1);
+ const slice = this.slices[this.activeSliceIndex];
+ if (this.mrng.nextInt(1, this.biasFactor) !== 1) {
+ this.nextIndexInSlice = 1;
+ this.lastIndexInSlice = slice.length - 1;
+ return new Value_1.Value(slice[0], undefined);
+ }
+ const rangeBoundaryA = this.mrng.nextInt(0, slice.length - 1);
+ const rangeBoundaryB = this.mrng.nextInt(0, slice.length - 1);
+ this.nextIndexInSlice = safeMathMin(rangeBoundaryA, rangeBoundaryB);
+ this.lastIndexInSlice = safeMathMax(rangeBoundaryA, rangeBoundaryB);
+ return new Value_1.Value(slice[this.nextIndexInSlice++], undefined);
+ }
+}
+exports.SlicedBasedGenerator = SlicedBasedGenerator;
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/interfaces/CustomSet.js b/node_modules/fast-check/lib/arbitrary/_internals/interfaces/CustomSet.js
new file mode 100644
index 0000000000000000000000000000000000000000..c8ad2e549bdc6801e0d1c80b0308d4b9bd4985ce
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/interfaces/CustomSet.js
@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/interfaces/Scheduler.js b/node_modules/fast-check/lib/arbitrary/_internals/interfaces/Scheduler.js
new file mode 100644
index 0000000000000000000000000000000000000000..c8ad2e549bdc6801e0d1c80b0308d4b9bd4985ce
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/interfaces/Scheduler.js
@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/interfaces/SlicedGenerator.js b/node_modules/fast-check/lib/arbitrary/_internals/interfaces/SlicedGenerator.js
new file mode 100644
index 0000000000000000000000000000000000000000..c8ad2e549bdc6801e0d1c80b0308d4b9bd4985ce
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/interfaces/SlicedGenerator.js
@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/mappers/ArrayToMap.js b/node_modules/fast-check/lib/arbitrary/_internals/mappers/ArrayToMap.js
new file mode 100644
index 0000000000000000000000000000000000000000..36b035ab85cb024a831494b89422bed4e1e67bc3
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/mappers/ArrayToMap.js
@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayToMapMapper = arrayToMapMapper;
+exports.arrayToMapUnmapper = arrayToMapUnmapper;
+function arrayToMapMapper(data) {
+ return new Map(data);
+}
+function arrayToMapUnmapper(value) {
+ if (typeof value !== 'object' || value === null) {
+ throw new Error('Incompatible instance received: should be a non-null object');
+ }
+ if (!('constructor' in value) || value.constructor !== Map) {
+ throw new Error('Incompatible instance received: should be of exact type Map');
+ }
+ return Array.from(value);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/mappers/ArrayToSet.js b/node_modules/fast-check/lib/arbitrary/_internals/mappers/ArrayToSet.js
new file mode 100644
index 0000000000000000000000000000000000000000..ad38ec5ffb48cd20163d56ef04fc076ae16ff407
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/mappers/ArrayToSet.js
@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayToSetMapper = arrayToSetMapper;
+exports.arrayToSetUnmapper = arrayToSetUnmapper;
+function arrayToSetMapper(data) {
+ return new Set(data);
+}
+function arrayToSetUnmapper(value) {
+ if (typeof value !== 'object' || value === null) {
+ throw new Error('Incompatible instance received: should be a non-null object');
+ }
+ if (!('constructor' in value) || value.constructor !== Set) {
+ throw new Error('Incompatible instance received: should be of exact type Set');
+ }
+ return Array.from(value);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/mappers/CharsToString.js b/node_modules/fast-check/lib/arbitrary/_internals/mappers/CharsToString.js
new file mode 100644
index 0000000000000000000000000000000000000000..e1308f316113458a122d3753f2bbe9f8d05b0790
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/mappers/CharsToString.js
@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.charsToStringMapper = charsToStringMapper;
+exports.charsToStringUnmapper = charsToStringUnmapper;
+const globals_1 = require("../../../utils/globals");
+function charsToStringMapper(tab) {
+ return (0, globals_1.safeJoin)(tab, '');
+}
+function charsToStringUnmapper(value) {
+ if (typeof value !== 'string') {
+ throw new Error('Cannot unmap the passed value');
+ }
+ return (0, globals_1.safeSplit)(value, '');
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/mappers/CodePointsToString.js b/node_modules/fast-check/lib/arbitrary/_internals/mappers/CodePointsToString.js
new file mode 100644
index 0000000000000000000000000000000000000000..a190a9f20037ea36d75fcac2070d678de0a7dd64
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/mappers/CodePointsToString.js
@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codePointsToStringMapper = codePointsToStringMapper;
+exports.codePointsToStringUnmapper = codePointsToStringUnmapper;
+const globals_1 = require("../../../utils/globals");
+function codePointsToStringMapper(tab) {
+ return (0, globals_1.safeJoin)(tab, '');
+}
+function codePointsToStringUnmapper(value) {
+ if (typeof value !== 'string') {
+ throw new Error('Cannot unmap the passed value');
+ }
+ return [...value];
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/mappers/EntitiesToIPv6.js b/node_modules/fast-check/lib/arbitrary/_internals/mappers/EntitiesToIPv6.js
new file mode 100644
index 0000000000000000000000000000000000000000..a80a6ffb724809366672281ce343866ce1828b49
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/mappers/EntitiesToIPv6.js
@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fullySpecifiedMapper = fullySpecifiedMapper;
+exports.fullySpecifiedUnmapper = fullySpecifiedUnmapper;
+exports.onlyTrailingMapper = onlyTrailingMapper;
+exports.onlyTrailingUnmapper = onlyTrailingUnmapper;
+exports.multiTrailingMapper = multiTrailingMapper;
+exports.multiTrailingUnmapper = multiTrailingUnmapper;
+exports.multiTrailingMapperOne = multiTrailingMapperOne;
+exports.multiTrailingUnmapperOne = multiTrailingUnmapperOne;
+exports.singleTrailingMapper = singleTrailingMapper;
+exports.singleTrailingUnmapper = singleTrailingUnmapper;
+exports.noTrailingMapper = noTrailingMapper;
+exports.noTrailingUnmapper = noTrailingUnmapper;
+const globals_1 = require("../../../utils/globals");
+function readBh(value) {
+ if (value.length === 0)
+ return [];
+ else
+ return (0, globals_1.safeSplit)(value, ':');
+}
+function extractEhAndL(value) {
+ const valueSplits = (0, globals_1.safeSplit)(value, ':');
+ if (valueSplits.length >= 2 && valueSplits[valueSplits.length - 1].length <= 4) {
+ return [
+ (0, globals_1.safeSlice)(valueSplits, 0, valueSplits.length - 2),
+ `${valueSplits[valueSplits.length - 2]}:${valueSplits[valueSplits.length - 1]}`,
+ ];
+ }
+ return [(0, globals_1.safeSlice)(valueSplits, 0, valueSplits.length - 1), valueSplits[valueSplits.length - 1]];
+}
+function fullySpecifiedMapper(data) {
+ return `${(0, globals_1.safeJoin)(data[0], ':')}:${data[1]}`;
+}
+function fullySpecifiedUnmapper(value) {
+ if (typeof value !== 'string')
+ throw new Error('Invalid type');
+ return extractEhAndL(value);
+}
+function onlyTrailingMapper(data) {
+ return `::${(0, globals_1.safeJoin)(data[0], ':')}:${data[1]}`;
+}
+function onlyTrailingUnmapper(value) {
+ if (typeof value !== 'string')
+ throw new Error('Invalid type');
+ if (!(0, globals_1.safeStartsWith)(value, '::'))
+ throw new Error('Invalid value');
+ return extractEhAndL((0, globals_1.safeSubstring)(value, 2));
+}
+function multiTrailingMapper(data) {
+ return `${(0, globals_1.safeJoin)(data[0], ':')}::${(0, globals_1.safeJoin)(data[1], ':')}:${data[2]}`;
+}
+function multiTrailingUnmapper(value) {
+ if (typeof value !== 'string')
+ throw new Error('Invalid type');
+ const [bhString, trailingString] = (0, globals_1.safeSplit)(value, '::', 2);
+ const [eh, l] = extractEhAndL(trailingString);
+ return [readBh(bhString), eh, l];
+}
+function multiTrailingMapperOne(data) {
+ return multiTrailingMapper([data[0], [data[1]], data[2]]);
+}
+function multiTrailingUnmapperOne(value) {
+ const out = multiTrailingUnmapper(value);
+ return [out[0], (0, globals_1.safeJoin)(out[1], ':'), out[2]];
+}
+function singleTrailingMapper(data) {
+ return `${(0, globals_1.safeJoin)(data[0], ':')}::${data[1]}`;
+}
+function singleTrailingUnmapper(value) {
+ if (typeof value !== 'string')
+ throw new Error('Invalid type');
+ const [bhString, trailing] = (0, globals_1.safeSplit)(value, '::', 2);
+ return [readBh(bhString), trailing];
+}
+function noTrailingMapper(data) {
+ return `${(0, globals_1.safeJoin)(data[0], ':')}::`;
+}
+function noTrailingUnmapper(value) {
+ if (typeof value !== 'string')
+ throw new Error('Invalid type');
+ if (!(0, globals_1.safeEndsWith)(value, '::'))
+ throw new Error('Invalid value');
+ return [readBh((0, globals_1.safeSubstring)(value, 0, value.length - 2))];
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/mappers/IndexToCharString.js b/node_modules/fast-check/lib/arbitrary/_internals/mappers/IndexToCharString.js
new file mode 100644
index 0000000000000000000000000000000000000000..9f203db7223b73bd5059f25102bfa4b3b7411fb5
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/mappers/IndexToCharString.js
@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.indexToCharStringMapper = void 0;
+exports.indexToCharStringUnmapper = indexToCharStringUnmapper;
+const globals_1 = require("../../../utils/globals");
+exports.indexToCharStringMapper = String.fromCodePoint;
+function indexToCharStringUnmapper(c) {
+ if (typeof c !== 'string') {
+ throw new Error('Cannot unmap non-string');
+ }
+ if (c.length === 0 || c.length > 2) {
+ throw new Error('Cannot unmap string with more or less than one character');
+ }
+ const c1 = (0, globals_1.safeCharCodeAt)(c, 0);
+ if (c.length === 1) {
+ return c1;
+ }
+ const c2 = (0, globals_1.safeCharCodeAt)(c, 1);
+ if (c1 < 0xd800 || c1 > 0xdbff || c2 < 0xdc00 || c2 > 0xdfff) {
+ throw new Error('Cannot unmap invalid surrogate pairs');
+ }
+ return c.codePointAt(0);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/mappers/IndexToMappedConstant.js b/node_modules/fast-check/lib/arbitrary/_internals/mappers/IndexToMappedConstant.js
new file mode 100644
index 0000000000000000000000000000000000000000..fe0e82d8b695674070f69dca718c678f89cadd52
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/mappers/IndexToMappedConstant.js
@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.indexToMappedConstantMapperFor = indexToMappedConstantMapperFor;
+exports.indexToMappedConstantUnmapperFor = indexToMappedConstantUnmapperFor;
+const globals_1 = require("../../../utils/globals");
+const safeObjectIs = Object.is;
+function buildDichotomyEntries(entries) {
+ let currentFrom = 0;
+ const dichotomyEntries = [];
+ for (const entry of entries) {
+ const from = currentFrom;
+ currentFrom = from + entry.num;
+ const to = currentFrom - 1;
+ dichotomyEntries.push({ from, to, entry });
+ }
+ return dichotomyEntries;
+}
+function findDichotomyEntry(dichotomyEntries, choiceIndex) {
+ let min = 0;
+ let max = dichotomyEntries.length;
+ while (max - min > 1) {
+ const mid = ~~((min + max) / 2);
+ if (choiceIndex < dichotomyEntries[mid].from) {
+ max = mid;
+ }
+ else {
+ min = mid;
+ }
+ }
+ return dichotomyEntries[min];
+}
+function indexToMappedConstantMapperFor(entries) {
+ const dichotomyEntries = buildDichotomyEntries(entries);
+ return function indexToMappedConstantMapper(choiceIndex) {
+ const dichotomyEntry = findDichotomyEntry(dichotomyEntries, choiceIndex);
+ return dichotomyEntry.entry.build(choiceIndex - dichotomyEntry.from);
+ };
+}
+function buildReverseMapping(entries) {
+ const reverseMapping = { mapping: new globals_1.Map(), negativeZeroIndex: undefined };
+ let choiceIndex = 0;
+ for (let entryIdx = 0; entryIdx !== entries.length; ++entryIdx) {
+ const entry = entries[entryIdx];
+ for (let idxInEntry = 0; idxInEntry !== entry.num; ++idxInEntry) {
+ const value = entry.build(idxInEntry);
+ if (value === 0 && 1 / value === globals_1.Number.NEGATIVE_INFINITY) {
+ reverseMapping.negativeZeroIndex = choiceIndex;
+ }
+ else {
+ (0, globals_1.safeMapSet)(reverseMapping.mapping, value, choiceIndex);
+ }
+ ++choiceIndex;
+ }
+ }
+ return reverseMapping;
+}
+function indexToMappedConstantUnmapperFor(entries) {
+ let reverseMapping = null;
+ return function indexToMappedConstantUnmapper(value) {
+ if (reverseMapping === null) {
+ reverseMapping = buildReverseMapping(entries);
+ }
+ const choiceIndex = safeObjectIs(value, -0)
+ ? reverseMapping.negativeZeroIndex
+ : (0, globals_1.safeMapGet)(reverseMapping.mapping, value);
+ if (choiceIndex === undefined) {
+ throw new globals_1.Error('Unknown value encountered cannot be built using this mapToConstant');
+ }
+ return choiceIndex;
+ };
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/mappers/IndexToPrintableIndex.js b/node_modules/fast-check/lib/arbitrary/_internals/mappers/IndexToPrintableIndex.js
new file mode 100644
index 0000000000000000000000000000000000000000..91c904d09e4d0c99bc8b28aa77f372bfd76cd24e
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/mappers/IndexToPrintableIndex.js
@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.indexToPrintableIndexMapper = indexToPrintableIndexMapper;
+exports.indexToPrintableIndexUnmapper = indexToPrintableIndexUnmapper;
+function indexToPrintableIndexMapper(v) {
+ if (v < 95)
+ return v + 0x20;
+ if (v <= 0x7e)
+ return v - 95;
+ return v;
+}
+function indexToPrintableIndexUnmapper(v) {
+ if (v >= 0x20 && v <= 0x7e)
+ return v - 0x20;
+ if (v >= 0 && v <= 0x1f)
+ return v + 95;
+ return v;
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/mappers/KeyValuePairsToObject.js b/node_modules/fast-check/lib/arbitrary/_internals/mappers/KeyValuePairsToObject.js
new file mode 100644
index 0000000000000000000000000000000000000000..f9200b46ae81f36ac8a290056e1994a89d8a861d
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/mappers/KeyValuePairsToObject.js
@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keyValuePairsToObjectMapper = keyValuePairsToObjectMapper;
+exports.keyValuePairsToObjectUnmapper = keyValuePairsToObjectUnmapper;
+const globals_1 = require("../../../utils/globals");
+const safeObjectCreate = Object.create;
+const safeObjectDefineProperty = Object.defineProperty;
+const safeObjectGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+const safeObjectGetPrototypeOf = Object.getPrototypeOf;
+const safeObjectGetOwnPropertySymbols = Object.getOwnPropertySymbols;
+const safeObjectGetOwnPropertyNames = Object.getOwnPropertyNames;
+const safeObjectEntries = Object.entries;
+function keyValuePairsToObjectMapper(definition) {
+ const obj = definition[1] ? safeObjectCreate(null) : {};
+ for (const keyValue of definition[0]) {
+ safeObjectDefineProperty(obj, keyValue[0], {
+ enumerable: true,
+ configurable: true,
+ writable: true,
+ value: keyValue[1],
+ });
+ }
+ return obj;
+}
+function buildIsValidPropertyNameFilter(obj) {
+ return function isValidPropertyNameFilter(key) {
+ const descriptor = safeObjectGetOwnPropertyDescriptor(obj, key);
+ return (descriptor !== undefined &&
+ !!descriptor.configurable &&
+ !!descriptor.enumerable &&
+ !!descriptor.writable &&
+ descriptor.get === undefined &&
+ descriptor.set === undefined);
+ };
+}
+function keyValuePairsToObjectUnmapper(value) {
+ if (typeof value !== 'object' || value === null) {
+ throw new globals_1.Error('Incompatible instance received: should be a non-null object');
+ }
+ const hasNullPrototype = safeObjectGetPrototypeOf(value) === null;
+ const hasObjectPrototype = 'constructor' in value && value.constructor === Object;
+ if (!hasNullPrototype && !hasObjectPrototype) {
+ throw new globals_1.Error('Incompatible instance received: should be of exact type Object');
+ }
+ if (safeObjectGetOwnPropertySymbols(value).length > 0) {
+ throw new globals_1.Error('Incompatible instance received: should contain symbols');
+ }
+ if (!(0, globals_1.safeEvery)(safeObjectGetOwnPropertyNames(value), buildIsValidPropertyNameFilter(value))) {
+ throw new globals_1.Error('Incompatible instance received: should contain only c/e/w properties without get/set');
+ }
+ return [safeObjectEntries(value), hasNullPrototype];
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/mappers/NatToStringifiedNat.js b/node_modules/fast-check/lib/arbitrary/_internals/mappers/NatToStringifiedNat.js
new file mode 100644
index 0000000000000000000000000000000000000000..d2f4497185b0b0c9bddd78889f9c6414929532b6
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/mappers/NatToStringifiedNat.js
@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.natToStringifiedNatMapper = natToStringifiedNatMapper;
+exports.tryParseStringifiedNat = tryParseStringifiedNat;
+exports.natToStringifiedNatUnmapper = natToStringifiedNatUnmapper;
+const globals_1 = require("../../../utils/globals");
+const safeNumberParseInt = Number.parseInt;
+function natToStringifiedNatMapper(options) {
+ const [style, v] = options;
+ switch (style) {
+ case 'oct':
+ return `0${(0, globals_1.safeNumberToString)(v, 8)}`;
+ case 'hex':
+ return `0x${(0, globals_1.safeNumberToString)(v, 16)}`;
+ case 'dec':
+ default:
+ return `${v}`;
+ }
+}
+function tryParseStringifiedNat(stringValue, radix) {
+ const parsedNat = safeNumberParseInt(stringValue, radix);
+ if ((0, globals_1.safeNumberToString)(parsedNat, radix) !== stringValue) {
+ throw new Error('Invalid value');
+ }
+ return parsedNat;
+}
+function natToStringifiedNatUnmapper(value) {
+ if (typeof value !== 'string') {
+ throw new Error('Invalid type');
+ }
+ if (value.length >= 2 && value[0] === '0') {
+ if (value[1] === 'x') {
+ return ['hex', tryParseStringifiedNat((0, globals_1.safeSubstring)(value, 2), 16)];
+ }
+ return ['oct', tryParseStringifiedNat((0, globals_1.safeSubstring)(value, 1), 8)];
+ }
+ return ['dec', tryParseStringifiedNat(value, 10)];
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/mappers/NumberToPaddedEight.js b/node_modules/fast-check/lib/arbitrary/_internals/mappers/NumberToPaddedEight.js
new file mode 100644
index 0000000000000000000000000000000000000000..9539bd2e7204615f7565e19f1720480d39f22682
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/mappers/NumberToPaddedEight.js
@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.numberToPaddedEightMapper = numberToPaddedEightMapper;
+exports.numberToPaddedEightUnmapper = numberToPaddedEightUnmapper;
+const globals_1 = require("../../../utils/globals");
+function numberToPaddedEightMapper(n) {
+ return (0, globals_1.safePadStart)((0, globals_1.safeNumberToString)(n, 16), 8, '0');
+}
+function numberToPaddedEightUnmapper(value) {
+ if (typeof value !== 'string') {
+ throw new Error('Unsupported type');
+ }
+ if (value.length !== 8) {
+ throw new Error('Unsupported value: invalid length');
+ }
+ const n = parseInt(value, 16);
+ if (value !== numberToPaddedEightMapper(n)) {
+ throw new Error('Unsupported value: invalid content');
+ }
+ return n;
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/mappers/PaddedEightsToUuid.js b/node_modules/fast-check/lib/arbitrary/_internals/mappers/PaddedEightsToUuid.js
new file mode 100644
index 0000000000000000000000000000000000000000..b958eff31036c355ed609f4ab5c7eb304e2ea963
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/mappers/PaddedEightsToUuid.js
@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paddedEightsToUuidMapper = paddedEightsToUuidMapper;
+exports.paddedEightsToUuidUnmapper = paddedEightsToUuidUnmapper;
+const globals_1 = require("../../../utils/globals");
+function paddedEightsToUuidMapper(t) {
+ return `${t[0]}-${(0, globals_1.safeSubstring)(t[1], 4)}-${(0, globals_1.safeSubstring)(t[1], 0, 4)}-${(0, globals_1.safeSubstring)(t[2], 0, 4)}-${(0, globals_1.safeSubstring)(t[2], 4)}${t[3]}`;
+}
+const UuidRegex = /^([0-9a-f]{8})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{12})$/;
+function paddedEightsToUuidUnmapper(value) {
+ if (typeof value !== 'string') {
+ throw new Error('Unsupported type');
+ }
+ const m = UuidRegex.exec(value);
+ if (m === null) {
+ throw new Error('Unsupported type');
+ }
+ return [m[1], m[3] + m[2], m[4] + (0, globals_1.safeSubstring)(m[5], 0, 4), (0, globals_1.safeSubstring)(m[5], 4)];
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/mappers/PartsToUrl.js b/node_modules/fast-check/lib/arbitrary/_internals/mappers/PartsToUrl.js
new file mode 100644
index 0000000000000000000000000000000000000000..20d1c042e3bad291b64a49b621cfbd1033a970a2
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/mappers/PartsToUrl.js
@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.partsToUrlMapper = partsToUrlMapper;
+exports.partsToUrlUnmapper = partsToUrlUnmapper;
+function partsToUrlMapper(data) {
+ const [scheme, authority, path] = data;
+ const query = data[3] === null ? '' : `?${data[3]}`;
+ const fragments = data[4] === null ? '' : `#${data[4]}`;
+ return `${scheme}://${authority}${path}${query}${fragments}`;
+}
+const UrlSplitRegex = /^([[A-Za-z][A-Za-z0-9+.-]*):\/\/([^/?#]*)([^?#]*)(\?[A-Za-z0-9\-._~!$&'()*+,;=:@/?%]*)?(#[A-Za-z0-9\-._~!$&'()*+,;=:@/?%]*)?$/;
+function partsToUrlUnmapper(value) {
+ if (typeof value !== 'string') {
+ throw new Error('Incompatible value received: type');
+ }
+ const m = UrlSplitRegex.exec(value);
+ if (m === null) {
+ throw new Error('Incompatible value received');
+ }
+ const scheme = m[1];
+ const authority = m[2];
+ const path = m[3];
+ const query = m[4];
+ const fragments = m[5];
+ return [
+ scheme,
+ authority,
+ path,
+ query !== undefined ? query.substring(1) : null,
+ fragments !== undefined ? fragments.substring(1) : null,
+ ];
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/mappers/PatternsToString.js b/node_modules/fast-check/lib/arbitrary/_internals/mappers/PatternsToString.js
new file mode 100644
index 0000000000000000000000000000000000000000..8c1395cc704965fdcd9bd7386229cf138d9fa3ee
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/mappers/PatternsToString.js
@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patternsToStringMapper = patternsToStringMapper;
+exports.patternsToStringUnmapperIsValidLength = patternsToStringUnmapperIsValidLength;
+exports.patternsToStringUnmapperFor = patternsToStringUnmapperFor;
+const MaxLengthFromMinLength_1 = require("../helpers/MaxLengthFromMinLength");
+const globals_1 = require("../../../utils/globals");
+const TokenizeString_1 = require("../helpers/TokenizeString");
+function patternsToStringMapper(tab) {
+ return (0, globals_1.safeJoin)(tab, '');
+}
+function minLengthFrom(constraints) {
+ return constraints.minLength !== undefined ? constraints.minLength : 0;
+}
+function maxLengthFrom(constraints) {
+ return constraints.maxLength !== undefined ? constraints.maxLength : MaxLengthFromMinLength_1.MaxLengthUpperBound;
+}
+function patternsToStringUnmapperIsValidLength(tokens, constraints) {
+ return minLengthFrom(constraints) <= tokens.length && tokens.length <= maxLengthFrom(constraints);
+}
+function patternsToStringUnmapperFor(patternsArb, constraints) {
+ return function patternsToStringUnmapper(value) {
+ if (typeof value !== 'string') {
+ throw new globals_1.Error('Unsupported value');
+ }
+ const tokens = (0, TokenizeString_1.tokenizeString)(patternsArb, value, minLengthFrom(constraints), maxLengthFrom(constraints));
+ if (tokens === undefined) {
+ throw new globals_1.Error('Unable to unmap received string');
+ }
+ return tokens;
+ };
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/mappers/SegmentsToPath.js b/node_modules/fast-check/lib/arbitrary/_internals/mappers/SegmentsToPath.js
new file mode 100644
index 0000000000000000000000000000000000000000..514a3a99e6a886130f30c022a69358c5c0faccaa
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/mappers/SegmentsToPath.js
@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.segmentsToPathMapper = segmentsToPathMapper;
+exports.segmentsToPathUnmapper = segmentsToPathUnmapper;
+const globals_1 = require("../../../utils/globals");
+function segmentsToPathMapper(segments) {
+ return (0, globals_1.safeJoin)((0, globals_1.safeMap)(segments, (v) => `/${v}`), '');
+}
+function segmentsToPathUnmapper(value) {
+ if (typeof value !== 'string') {
+ throw new Error('Incompatible value received: type');
+ }
+ if (value.length !== 0 && value[0] !== '/') {
+ throw new Error('Incompatible value received: start');
+ }
+ return (0, globals_1.safeSplice)((0, globals_1.safeSplit)(value, '/'), 1);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/mappers/StringToBase64.js b/node_modules/fast-check/lib/arbitrary/_internals/mappers/StringToBase64.js
new file mode 100644
index 0000000000000000000000000000000000000000..bcb5278812325520c2678f7ac833873513af5d4e
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/mappers/StringToBase64.js
@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringToBase64Mapper = stringToBase64Mapper;
+exports.stringToBase64Unmapper = stringToBase64Unmapper;
+const globals_1 = require("../../../utils/globals");
+function stringToBase64Mapper(s) {
+ switch (s.length % 4) {
+ case 0:
+ return s;
+ case 3:
+ return `${s}=`;
+ case 2:
+ return `${s}==`;
+ default:
+ return (0, globals_1.safeSubstring)(s, 1);
+ }
+}
+function stringToBase64Unmapper(value) {
+ if (typeof value !== 'string' || value.length % 4 !== 0) {
+ throw new Error('Invalid string received');
+ }
+ const lastTrailingIndex = value.indexOf('=');
+ if (lastTrailingIndex === -1) {
+ return value;
+ }
+ const numTrailings = value.length - lastTrailingIndex;
+ if (numTrailings > 2) {
+ throw new Error('Cannot unmap the passed value');
+ }
+ return (0, globals_1.safeSubstring)(value, 0, lastTrailingIndex);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/mappers/TimeToDate.js b/node_modules/fast-check/lib/arbitrary/_internals/mappers/TimeToDate.js
new file mode 100644
index 0000000000000000000000000000000000000000..480953d432a4268ba77c341f4347d5cd5de85e04
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/mappers/TimeToDate.js
@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.timeToDateMapper = timeToDateMapper;
+exports.timeToDateUnmapper = timeToDateUnmapper;
+exports.timeToDateMapperWithNaN = timeToDateMapperWithNaN;
+exports.timeToDateUnmapperWithNaN = timeToDateUnmapperWithNaN;
+const globals_1 = require("../../../utils/globals");
+const safeNaN = Number.NaN;
+const safeNumberIsNaN = Number.isNaN;
+function timeToDateMapper(time) {
+ return new globals_1.Date(time);
+}
+function timeToDateUnmapper(value) {
+ if (!(value instanceof globals_1.Date) || value.constructor !== globals_1.Date) {
+ throw new globals_1.Error('Not a valid value for date unmapper');
+ }
+ return (0, globals_1.safeGetTime)(value);
+}
+function timeToDateMapperWithNaN(valueForNaN) {
+ return (time) => {
+ return time === valueForNaN ? new globals_1.Date(safeNaN) : timeToDateMapper(time);
+ };
+}
+function timeToDateUnmapperWithNaN(valueForNaN) {
+ return (value) => {
+ const time = timeToDateUnmapper(value);
+ return safeNumberIsNaN(time) ? valueForNaN : time;
+ };
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/mappers/UintToBase32String.js b/node_modules/fast-check/lib/arbitrary/_internals/mappers/UintToBase32String.js
new file mode 100644
index 0000000000000000000000000000000000000000..d50fdfa7db3ffa73ccb0b388c2e12fa92f0f5070
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/mappers/UintToBase32String.js
@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uintToBase32StringMapper = uintToBase32StringMapper;
+exports.paddedUintToBase32StringMapper = paddedUintToBase32StringMapper;
+exports.uintToBase32StringUnmapper = uintToBase32StringUnmapper;
+const globals_1 = require("../../../utils/globals");
+const encodeSymbolLookupTable = {
+ 10: 'A',
+ 11: 'B',
+ 12: 'C',
+ 13: 'D',
+ 14: 'E',
+ 15: 'F',
+ 16: 'G',
+ 17: 'H',
+ 18: 'J',
+ 19: 'K',
+ 20: 'M',
+ 21: 'N',
+ 22: 'P',
+ 23: 'Q',
+ 24: 'R',
+ 25: 'S',
+ 26: 'T',
+ 27: 'V',
+ 28: 'W',
+ 29: 'X',
+ 30: 'Y',
+ 31: 'Z',
+};
+const decodeSymbolLookupTable = {
+ '0': 0,
+ '1': 1,
+ '2': 2,
+ '3': 3,
+ '4': 4,
+ '5': 5,
+ '6': 6,
+ '7': 7,
+ '8': 8,
+ '9': 9,
+ A: 10,
+ B: 11,
+ C: 12,
+ D: 13,
+ E: 14,
+ F: 15,
+ G: 16,
+ H: 17,
+ J: 18,
+ K: 19,
+ M: 20,
+ N: 21,
+ P: 22,
+ Q: 23,
+ R: 24,
+ S: 25,
+ T: 26,
+ V: 27,
+ W: 28,
+ X: 29,
+ Y: 30,
+ Z: 31,
+};
+function encodeSymbol(symbol) {
+ return symbol < 10 ? (0, globals_1.String)(symbol) : encodeSymbolLookupTable[symbol];
+}
+function pad(value, paddingLength) {
+ let extraPadding = '';
+ while (value.length + extraPadding.length < paddingLength) {
+ extraPadding += '0';
+ }
+ return extraPadding + value;
+}
+function smallUintToBase32StringMapper(num) {
+ let base32Str = '';
+ for (let remaining = num; remaining !== 0;) {
+ const next = remaining >> 5;
+ const current = remaining - (next << 5);
+ base32Str = encodeSymbol(current) + base32Str;
+ remaining = next;
+ }
+ return base32Str;
+}
+function uintToBase32StringMapper(num, paddingLength) {
+ const head = ~~(num / 0x40000000);
+ const tail = num & 0x3fffffff;
+ return pad(smallUintToBase32StringMapper(head), paddingLength - 6) + pad(smallUintToBase32StringMapper(tail), 6);
+}
+function paddedUintToBase32StringMapper(paddingLength) {
+ return function padded(num) {
+ return uintToBase32StringMapper(num, paddingLength);
+ };
+}
+function uintToBase32StringUnmapper(value) {
+ if (typeof value !== 'string') {
+ throw new globals_1.Error('Unsupported type');
+ }
+ let accumulated = 0;
+ let power = 1;
+ for (let index = value.length - 1; index >= 0; --index) {
+ const char = value[index];
+ const numericForChar = decodeSymbolLookupTable[char];
+ if (numericForChar === undefined) {
+ throw new globals_1.Error('Unsupported type');
+ }
+ accumulated += numericForChar * power;
+ power *= 32;
+ }
+ return accumulated;
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/mappers/UnboxedToBoxed.js b/node_modules/fast-check/lib/arbitrary/_internals/mappers/UnboxedToBoxed.js
new file mode 100644
index 0000000000000000000000000000000000000000..5a54223dfbfbcda86cd84626b4f5cf111678965a
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/mappers/UnboxedToBoxed.js
@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unboxedToBoxedMapper = unboxedToBoxedMapper;
+exports.unboxedToBoxedUnmapper = unboxedToBoxedUnmapper;
+const globals_1 = require("../../../utils/globals");
+function unboxedToBoxedMapper(value) {
+ switch (typeof value) {
+ case 'boolean':
+ return new globals_1.Boolean(value);
+ case 'number':
+ return new globals_1.Number(value);
+ case 'string':
+ return new globals_1.String(value);
+ default:
+ return value;
+ }
+}
+function unboxedToBoxedUnmapper(value) {
+ if (typeof value !== 'object' || value === null || !('constructor' in value)) {
+ return value;
+ }
+ return value.constructor === globals_1.Boolean || value.constructor === globals_1.Number || value.constructor === globals_1.String
+ ? value.valueOf()
+ : value;
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/mappers/ValuesAndSeparateKeysToObject.js b/node_modules/fast-check/lib/arbitrary/_internals/mappers/ValuesAndSeparateKeysToObject.js
new file mode 100644
index 0000000000000000000000000000000000000000..c83d16aa3c8288cbbba1faff9f6e9c80c016d31b
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/mappers/ValuesAndSeparateKeysToObject.js
@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildValuesAndSeparateKeysToObjectMapper = buildValuesAndSeparateKeysToObjectMapper;
+exports.buildValuesAndSeparateKeysToObjectUnmapper = buildValuesAndSeparateKeysToObjectUnmapper;
+const globals_1 = require("../../../utils/globals");
+const safeObjectCreate = Object.create;
+const safeObjectDefineProperty = Object.defineProperty;
+const safeObjectGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+const safeObjectGetOwnPropertyNames = Object.getOwnPropertyNames;
+const safeObjectGetOwnPropertySymbols = Object.getOwnPropertySymbols;
+function buildValuesAndSeparateKeysToObjectMapper(keys, noKeyValue) {
+ return function valuesAndSeparateKeysToObjectMapper(definition) {
+ const obj = definition[1] ? safeObjectCreate(null) : {};
+ for (let idx = 0; idx !== keys.length; ++idx) {
+ const valueWrapper = definition[0][idx];
+ if (valueWrapper !== noKeyValue) {
+ safeObjectDefineProperty(obj, keys[idx], {
+ value: valueWrapper,
+ configurable: true,
+ enumerable: true,
+ writable: true,
+ });
+ }
+ }
+ return obj;
+ };
+}
+function buildValuesAndSeparateKeysToObjectUnmapper(keys, noKeyValue) {
+ return function valuesAndSeparateKeysToObjectUnmapper(value) {
+ if (typeof value !== 'object' || value === null) {
+ throw new Error('Incompatible instance received: should be a non-null object');
+ }
+ const hasNullPrototype = Object.getPrototypeOf(value) === null;
+ const hasObjectPrototype = 'constructor' in value && value.constructor === Object;
+ if (!hasNullPrototype && !hasObjectPrototype) {
+ throw new Error('Incompatible instance received: should be of exact type Object');
+ }
+ let extractedPropertiesCount = 0;
+ const extractedValues = [];
+ for (let idx = 0; idx !== keys.length; ++idx) {
+ const descriptor = safeObjectGetOwnPropertyDescriptor(value, keys[idx]);
+ if (descriptor !== undefined) {
+ if (!descriptor.configurable || !descriptor.enumerable || !descriptor.writable) {
+ throw new Error('Incompatible instance received: should contain only c/e/w properties');
+ }
+ if (descriptor.get !== undefined || descriptor.set !== undefined) {
+ throw new Error('Incompatible instance received: should contain only no get/set properties');
+ }
+ ++extractedPropertiesCount;
+ (0, globals_1.safePush)(extractedValues, descriptor.value);
+ }
+ else {
+ (0, globals_1.safePush)(extractedValues, noKeyValue);
+ }
+ }
+ const namePropertiesCount = safeObjectGetOwnPropertyNames(value).length;
+ const symbolPropertiesCount = safeObjectGetOwnPropertySymbols(value).length;
+ if (extractedPropertiesCount !== namePropertiesCount + symbolPropertiesCount) {
+ throw new Error('Incompatible instance received: should not contain extra properties');
+ }
+ return [extractedValues, hasNullPrototype];
+ };
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/mappers/VersionsApplierForUuid.js b/node_modules/fast-check/lib/arbitrary/_internals/mappers/VersionsApplierForUuid.js
new file mode 100644
index 0000000000000000000000000000000000000000..97a0fbaf04c04e65c44aec6e222078ba3d07db2d
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/mappers/VersionsApplierForUuid.js
@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildVersionsAppliersForUuid = buildVersionsAppliersForUuid;
+const globals_1 = require("../../../utils/globals");
+const quickNumberToHexaString = '0123456789abcdef';
+function buildVersionsAppliersForUuid(versions) {
+ const mapping = {};
+ const reversedMapping = {};
+ for (let index = 0; index !== versions.length; ++index) {
+ const from = quickNumberToHexaString[index];
+ const to = quickNumberToHexaString[versions[index]];
+ mapping[from] = to;
+ reversedMapping[to] = from;
+ }
+ function versionsApplierMapper(value) {
+ return mapping[value[0]] + (0, globals_1.safeSubstring)(value, 1);
+ }
+ function versionsApplierUnmapper(value) {
+ if (typeof value !== 'string') {
+ throw new globals_1.Error('Cannot produce non-string values');
+ }
+ const rev = reversedMapping[value[0]];
+ if (rev === undefined) {
+ throw new globals_1.Error('Cannot produce strings not starting by the version in hexa code');
+ }
+ return rev + (0, globals_1.safeSubstring)(value, 1);
+ }
+ return { versionsApplierMapper, versionsApplierUnmapper };
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_internals/mappers/WordsToLorem.js b/node_modules/fast-check/lib/arbitrary/_internals/mappers/WordsToLorem.js
new file mode 100644
index 0000000000000000000000000000000000000000..8eee72da546af1f45454fef03a9cf44e63fdd7d8
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_internals/mappers/WordsToLorem.js
@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wordsToJoinedStringMapper = wordsToJoinedStringMapper;
+exports.wordsToJoinedStringUnmapperFor = wordsToJoinedStringUnmapperFor;
+exports.wordsToSentenceMapper = wordsToSentenceMapper;
+exports.wordsToSentenceUnmapperFor = wordsToSentenceUnmapperFor;
+exports.sentencesToParagraphMapper = sentencesToParagraphMapper;
+exports.sentencesToParagraphUnmapper = sentencesToParagraphUnmapper;
+const globals_1 = require("../../../utils/globals");
+function wordsToJoinedStringMapper(words) {
+ return (0, globals_1.safeJoin)((0, globals_1.safeMap)(words, (w) => (w[w.length - 1] === ',' ? (0, globals_1.safeSubstring)(w, 0, w.length - 1) : w)), ' ');
+}
+function wordsToJoinedStringUnmapperFor(wordsArbitrary) {
+ return function wordsToJoinedStringUnmapper(value) {
+ if (typeof value !== 'string') {
+ throw new Error('Unsupported type');
+ }
+ const words = [];
+ for (const candidate of (0, globals_1.safeSplit)(value, ' ')) {
+ if (wordsArbitrary.canShrinkWithoutContext(candidate))
+ (0, globals_1.safePush)(words, candidate);
+ else if (wordsArbitrary.canShrinkWithoutContext(candidate + ','))
+ (0, globals_1.safePush)(words, candidate + ',');
+ else
+ throw new Error('Unsupported word');
+ }
+ return words;
+ };
+}
+function wordsToSentenceMapper(words) {
+ let sentence = (0, globals_1.safeJoin)(words, ' ');
+ if (sentence[sentence.length - 1] === ',') {
+ sentence = (0, globals_1.safeSubstring)(sentence, 0, sentence.length - 1);
+ }
+ return (0, globals_1.safeToUpperCase)(sentence[0]) + (0, globals_1.safeSubstring)(sentence, 1) + '.';
+}
+function wordsToSentenceUnmapperFor(wordsArbitrary) {
+ return function wordsToSentenceUnmapper(value) {
+ if (typeof value !== 'string') {
+ throw new Error('Unsupported type');
+ }
+ if (value.length < 2 ||
+ value[value.length - 1] !== '.' ||
+ value[value.length - 2] === ',' ||
+ (0, globals_1.safeToUpperCase)((0, globals_1.safeToLowerCase)(value[0])) !== value[0]) {
+ throw new Error('Unsupported value');
+ }
+ const adaptedValue = (0, globals_1.safeToLowerCase)(value[0]) + (0, globals_1.safeSubstring)(value, 1, value.length - 1);
+ const words = [];
+ const candidates = (0, globals_1.safeSplit)(adaptedValue, ' ');
+ for (let idx = 0; idx !== candidates.length; ++idx) {
+ const candidate = candidates[idx];
+ if (wordsArbitrary.canShrinkWithoutContext(candidate))
+ (0, globals_1.safePush)(words, candidate);
+ else if (idx === candidates.length - 1 && wordsArbitrary.canShrinkWithoutContext(candidate + ','))
+ (0, globals_1.safePush)(words, candidate + ',');
+ else
+ throw new Error('Unsupported word');
+ }
+ return words;
+ };
+}
+function sentencesToParagraphMapper(sentences) {
+ return (0, globals_1.safeJoin)(sentences, ' ');
+}
+function sentencesToParagraphUnmapper(value) {
+ if (typeof value !== 'string') {
+ throw new Error('Unsupported type');
+ }
+ const sentences = (0, globals_1.safeSplit)(value, '. ');
+ for (let idx = 0; idx < sentences.length - 1; ++idx) {
+ sentences[idx] += '.';
+ }
+ return sentences;
+}
diff --git a/node_modules/fast-check/lib/arbitrary/_shared/StringSharedConstraints.js b/node_modules/fast-check/lib/arbitrary/_shared/StringSharedConstraints.js
new file mode 100644
index 0000000000000000000000000000000000000000..c8ad2e549bdc6801e0d1c80b0308d4b9bd4985ce
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/_shared/StringSharedConstraints.js
@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
diff --git a/node_modules/fast-check/lib/arbitrary/anything.js b/node_modules/fast-check/lib/arbitrary/anything.js
new file mode 100644
index 0000000000000000000000000000000000000000..438f5802f1fe68d87272d15165b35890bc9fe0d6
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/anything.js
@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.anything = anything;
+const AnyArbitraryBuilder_1 = require("./_internals/builders/AnyArbitraryBuilder");
+const QualifiedObjectConstraints_1 = require("./_internals/helpers/QualifiedObjectConstraints");
+function anything(constraints) {
+ return (0, AnyArbitraryBuilder_1.anyArbitraryBuilder)((0, QualifiedObjectConstraints_1.toQualifiedObjectConstraints)(constraints));
+}
diff --git a/node_modules/fast-check/lib/arbitrary/array.js b/node_modules/fast-check/lib/arbitrary/array.js
new file mode 100644
index 0000000000000000000000000000000000000000..c6573fd311b835b3d055e184c86082fb3a7a4927
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/array.js
@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.array = array;
+const ArrayArbitrary_1 = require("./_internals/ArrayArbitrary");
+const MaxLengthFromMinLength_1 = require("./_internals/helpers/MaxLengthFromMinLength");
+function array(arb, constraints = {}) {
+ const size = constraints.size;
+ const minLength = constraints.minLength || 0;
+ const maxLengthOrUnset = constraints.maxLength;
+ const depthIdentifier = constraints.depthIdentifier;
+ const maxLength = maxLengthOrUnset !== undefined ? maxLengthOrUnset : MaxLengthFromMinLength_1.MaxLengthUpperBound;
+ const specifiedMaxLength = maxLengthOrUnset !== undefined;
+ const maxGeneratedLength = (0, MaxLengthFromMinLength_1.maxGeneratedLengthFromSizeForArbitrary)(size, minLength, maxLength, specifiedMaxLength);
+ const customSlices = constraints.experimentalCustomSlices || [];
+ return new ArrayArbitrary_1.ArrayArbitrary(arb, minLength, maxGeneratedLength, maxLength, depthIdentifier, undefined, customSlices);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/ascii.js b/node_modules/fast-check/lib/arbitrary/ascii.js
new file mode 100644
index 0000000000000000000000000000000000000000..26b824667257bd0e954ec49411e3ad42a62ad3b5
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/ascii.js
@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ascii = ascii;
+const CharacterArbitraryBuilder_1 = require("./_internals/builders/CharacterArbitraryBuilder");
+const IndexToPrintableIndex_1 = require("./_internals/mappers/IndexToPrintableIndex");
+function ascii() {
+ return (0, CharacterArbitraryBuilder_1.buildCharacterArbitrary)(0x00, 0x7f, IndexToPrintableIndex_1.indexToPrintableIndexMapper, IndexToPrintableIndex_1.indexToPrintableIndexUnmapper);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/asciiString.js b/node_modules/fast-check/lib/arbitrary/asciiString.js
new file mode 100644
index 0000000000000000000000000000000000000000..dfe5ea6363a540d04fadc4490ede225b3c1654f2
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/asciiString.js
@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asciiString = asciiString;
+const array_1 = require("./array");
+const ascii_1 = require("./ascii");
+const CodePointsToString_1 = require("./_internals/mappers/CodePointsToString");
+const SlicesForStringBuilder_1 = require("./_internals/helpers/SlicesForStringBuilder");
+const safeObjectAssign = Object.assign;
+function asciiString(constraints = {}) {
+ const charArbitrary = (0, ascii_1.ascii)();
+ const experimentalCustomSlices = (0, SlicesForStringBuilder_1.createSlicesForStringLegacy)(charArbitrary, CodePointsToString_1.codePointsToStringUnmapper);
+ const enrichedConstraints = safeObjectAssign(safeObjectAssign({}, constraints), {
+ experimentalCustomSlices,
+ });
+ return (0, array_1.array)(charArbitrary, enrichedConstraints).map(CodePointsToString_1.codePointsToStringMapper, CodePointsToString_1.codePointsToStringUnmapper);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/base64.js b/node_modules/fast-check/lib/arbitrary/base64.js
new file mode 100644
index 0000000000000000000000000000000000000000..4e00b8309bdd838b642db5d487e17cf837b90378
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/base64.js
@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.base64 = base64;
+const CharacterArbitraryBuilder_1 = require("./_internals/builders/CharacterArbitraryBuilder");
+function base64Mapper(v) {
+ if (v < 26)
+ return v + 65;
+ if (v < 52)
+ return v + 97 - 26;
+ if (v < 62)
+ return v + 48 - 52;
+ return v === 62 ? 43 : 47;
+}
+function base64Unmapper(v) {
+ if (v >= 65 && v <= 90)
+ return v - 65;
+ if (v >= 97 && v <= 122)
+ return v - 97 + 26;
+ if (v >= 48 && v <= 57)
+ return v - 48 + 52;
+ return v === 43 ? 62 : v === 47 ? 63 : -1;
+}
+function base64() {
+ return (0, CharacterArbitraryBuilder_1.buildCharacterArbitrary)(0, 63, base64Mapper, base64Unmapper);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/base64String.js b/node_modules/fast-check/lib/arbitrary/base64String.js
new file mode 100644
index 0000000000000000000000000000000000000000..1387a316162389faf6f8c5efeaaa1e52c3846625
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/base64String.js
@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.base64String = base64String;
+const array_1 = require("./array");
+const base64_1 = require("./base64");
+const MaxLengthFromMinLength_1 = require("./_internals/helpers/MaxLengthFromMinLength");
+const CodePointsToString_1 = require("./_internals/mappers/CodePointsToString");
+const StringToBase64_1 = require("./_internals/mappers/StringToBase64");
+const SlicesForStringBuilder_1 = require("./_internals/helpers/SlicesForStringBuilder");
+function base64String(constraints = {}) {
+ const { minLength: unscaledMinLength = 0, maxLength: unscaledMaxLength = MaxLengthFromMinLength_1.MaxLengthUpperBound, size } = constraints;
+ const minLength = unscaledMinLength + 3 - ((unscaledMinLength + 3) % 4);
+ const maxLength = unscaledMaxLength - (unscaledMaxLength % 4);
+ const requestedSize = constraints.maxLength === undefined && size === undefined ? '=' : size;
+ if (minLength > maxLength)
+ throw new Error('Minimal length should be inferior or equal to maximal length');
+ if (minLength % 4 !== 0)
+ throw new Error('Minimal length of base64 strings must be a multiple of 4');
+ if (maxLength % 4 !== 0)
+ throw new Error('Maximal length of base64 strings must be a multiple of 4');
+ const charArbitrary = (0, base64_1.base64)();
+ const experimentalCustomSlices = (0, SlicesForStringBuilder_1.createSlicesForStringLegacy)(charArbitrary, CodePointsToString_1.codePointsToStringUnmapper);
+ const enrichedConstraints = {
+ minLength,
+ maxLength,
+ size: requestedSize,
+ experimentalCustomSlices,
+ };
+ return (0, array_1.array)(charArbitrary, enrichedConstraints)
+ .map(CodePointsToString_1.codePointsToStringMapper, CodePointsToString_1.codePointsToStringUnmapper)
+ .map(StringToBase64_1.stringToBase64Mapper, StringToBase64_1.stringToBase64Unmapper);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/bigInt.js b/node_modules/fast-check/lib/arbitrary/bigInt.js
new file mode 100644
index 0000000000000000000000000000000000000000..97a2904bda95e3a8e1cac7db6b76b33f7a15d36f
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/bigInt.js
@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bigInt = bigInt;
+const globals_1 = require("../utils/globals");
+const BigIntArbitrary_1 = require("./_internals/BigIntArbitrary");
+function buildCompleteBigIntConstraints(constraints) {
+ const DefaultPow = 256;
+ const DefaultMin = (0, globals_1.BigInt)(-1) << (0, globals_1.BigInt)(DefaultPow - 1);
+ const DefaultMax = ((0, globals_1.BigInt)(1) << (0, globals_1.BigInt)(DefaultPow - 1)) - (0, globals_1.BigInt)(1);
+ const min = constraints.min;
+ const max = constraints.max;
+ return {
+ min: min !== undefined ? min : DefaultMin - (max !== undefined && max < (0, globals_1.BigInt)(0) ? max * max : (0, globals_1.BigInt)(0)),
+ max: max !== undefined ? max : DefaultMax + (min !== undefined && min > (0, globals_1.BigInt)(0) ? min * min : (0, globals_1.BigInt)(0)),
+ };
+}
+function extractBigIntConstraints(args) {
+ if (args[0] === undefined) {
+ return {};
+ }
+ if (args[1] === undefined) {
+ const constraints = args[0];
+ return constraints;
+ }
+ return { min: args[0], max: args[1] };
+}
+function bigInt(...args) {
+ const constraints = buildCompleteBigIntConstraints(extractBigIntConstraints(args));
+ if (constraints.min > constraints.max) {
+ throw new Error('fc.bigInt expects max to be greater than or equal to min');
+ }
+ return new BigIntArbitrary_1.BigIntArbitrary(constraints.min, constraints.max);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/bigInt64Array.js b/node_modules/fast-check/lib/arbitrary/bigInt64Array.js
new file mode 100644
index 0000000000000000000000000000000000000000..36382d01c54dde7755d39377b36e14b41c2159d2
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/bigInt64Array.js
@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bigInt64Array = bigInt64Array;
+const globals_1 = require("../utils/globals");
+const bigInt_1 = require("./bigInt");
+const TypedIntArrayArbitraryBuilder_1 = require("./_internals/builders/TypedIntArrayArbitraryBuilder");
+function bigInt64Array(constraints = {}) {
+ return (0, TypedIntArrayArbitraryBuilder_1.typedIntArrayArbitraryArbitraryBuilder)(constraints, (0, globals_1.BigInt)('-9223372036854775808'), (0, globals_1.BigInt)('9223372036854775807'), globals_1.BigInt64Array, bigInt_1.bigInt);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/bigIntN.js b/node_modules/fast-check/lib/arbitrary/bigIntN.js
new file mode 100644
index 0000000000000000000000000000000000000000..3809d5b0a77739711deed35c601e72ec1ec4fd61
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/bigIntN.js
@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bigIntN = bigIntN;
+const globals_1 = require("../utils/globals");
+const BigIntArbitrary_1 = require("./_internals/BigIntArbitrary");
+function bigIntN(n) {
+ if (n < 1) {
+ throw new Error('fc.bigIntN expects requested number of bits to be superior or equal to 1');
+ }
+ const min = (0, globals_1.BigInt)(-1) << (0, globals_1.BigInt)(n - 1);
+ const max = ((0, globals_1.BigInt)(1) << (0, globals_1.BigInt)(n - 1)) - (0, globals_1.BigInt)(1);
+ return new BigIntArbitrary_1.BigIntArbitrary(min, max);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/bigUint.js b/node_modules/fast-check/lib/arbitrary/bigUint.js
new file mode 100644
index 0000000000000000000000000000000000000000..0e0152db698bd12b2a12b8b5ae99a4b82b878795
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/bigUint.js
@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bigUint = bigUint;
+const globals_1 = require("../utils/globals");
+const BigIntArbitrary_1 = require("./_internals/BigIntArbitrary");
+function computeDefaultMax() {
+ return ((0, globals_1.BigInt)(1) << (0, globals_1.BigInt)(256)) - (0, globals_1.BigInt)(1);
+}
+function bigUint(constraints) {
+ const requestedMax = typeof constraints === 'object' ? constraints.max : constraints;
+ const max = requestedMax !== undefined ? requestedMax : computeDefaultMax();
+ if (max < 0) {
+ throw new Error('fc.bigUint expects max to be greater than or equal to zero');
+ }
+ return new BigIntArbitrary_1.BigIntArbitrary((0, globals_1.BigInt)(0), max);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/bigUint64Array.js b/node_modules/fast-check/lib/arbitrary/bigUint64Array.js
new file mode 100644
index 0000000000000000000000000000000000000000..268fa2533c2d865b41747b1b66d47f0589dbf18c
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/bigUint64Array.js
@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bigUint64Array = bigUint64Array;
+const globals_1 = require("../utils/globals");
+const bigInt_1 = require("./bigInt");
+const TypedIntArrayArbitraryBuilder_1 = require("./_internals/builders/TypedIntArrayArbitraryBuilder");
+function bigUint64Array(constraints = {}) {
+ return (0, TypedIntArrayArbitraryBuilder_1.typedIntArrayArbitraryArbitraryBuilder)(constraints, (0, globals_1.BigInt)(0), (0, globals_1.BigInt)('18446744073709551615'), globals_1.BigUint64Array, bigInt_1.bigInt);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/bigUintN.js b/node_modules/fast-check/lib/arbitrary/bigUintN.js
new file mode 100644
index 0000000000000000000000000000000000000000..0f728a797ef386d54326842f4a97efeb7ad214d9
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/bigUintN.js
@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bigUintN = bigUintN;
+const globals_1 = require("../utils/globals");
+const BigIntArbitrary_1 = require("./_internals/BigIntArbitrary");
+function bigUintN(n) {
+ if (n < 0) {
+ throw new Error('fc.bigUintN expects requested number of bits to be superior or equal to 0');
+ }
+ const min = (0, globals_1.BigInt)(0);
+ const max = ((0, globals_1.BigInt)(1) << (0, globals_1.BigInt)(n)) - (0, globals_1.BigInt)(1);
+ return new BigIntArbitrary_1.BigIntArbitrary(min, max);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/boolean.js b/node_modules/fast-check/lib/arbitrary/boolean.js
new file mode 100644
index 0000000000000000000000000000000000000000..2ab488044b52302ba616f6472ca0462d02a9c433
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/boolean.js
@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.boolean = boolean;
+const integer_1 = require("./integer");
+const noBias_1 = require("./noBias");
+function booleanMapper(v) {
+ return v === 1;
+}
+function booleanUnmapper(v) {
+ if (typeof v !== 'boolean')
+ throw new Error('Unsupported input type');
+ return v === true ? 1 : 0;
+}
+function boolean() {
+ return (0, noBias_1.noBias)((0, integer_1.integer)({ min: 0, max: 1 }).map(booleanMapper, booleanUnmapper));
+}
diff --git a/node_modules/fast-check/lib/arbitrary/char.js b/node_modules/fast-check/lib/arbitrary/char.js
new file mode 100644
index 0000000000000000000000000000000000000000..ee5cb96fd3249f89a45d1e575cc30f3813eac670
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/char.js
@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.char = char;
+const CharacterArbitraryBuilder_1 = require("./_internals/builders/CharacterArbitraryBuilder");
+function identity(v) {
+ return v;
+}
+function char() {
+ return (0, CharacterArbitraryBuilder_1.buildCharacterArbitrary)(0x20, 0x7e, identity, identity);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/char16bits.js b/node_modules/fast-check/lib/arbitrary/char16bits.js
new file mode 100644
index 0000000000000000000000000000000000000000..258bd9d048ded476a33be838f4dcffbdc8e415d2
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/char16bits.js
@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.char16bits = char16bits;
+const CharacterArbitraryBuilder_1 = require("./_internals/builders/CharacterArbitraryBuilder");
+const IndexToPrintableIndex_1 = require("./_internals/mappers/IndexToPrintableIndex");
+function char16bits() {
+ return (0, CharacterArbitraryBuilder_1.buildCharacterArbitrary)(0x0000, 0xffff, IndexToPrintableIndex_1.indexToPrintableIndexMapper, IndexToPrintableIndex_1.indexToPrintableIndexUnmapper);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/clone.js b/node_modules/fast-check/lib/arbitrary/clone.js
new file mode 100644
index 0000000000000000000000000000000000000000..e9abceca4beb594fcf29b36fba9f9c64d64c6acb
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/clone.js
@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clone = clone;
+const CloneArbitrary_1 = require("./_internals/CloneArbitrary");
+function clone(arb, numValues) {
+ return new CloneArbitrary_1.CloneArbitrary(arb, numValues);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/commands.js b/node_modules/fast-check/lib/arbitrary/commands.js
new file mode 100644
index 0000000000000000000000000000000000000000..40112e872494e53d1eaff7774969e18bd9cc0bb4
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/commands.js
@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commands = commands;
+const CommandsArbitrary_1 = require("./_internals/CommandsArbitrary");
+const MaxLengthFromMinLength_1 = require("./_internals/helpers/MaxLengthFromMinLength");
+function commands(commandArbs, constraints = {}) {
+ const { size, maxCommands = MaxLengthFromMinLength_1.MaxLengthUpperBound, disableReplayLog = false, replayPath = null } = constraints;
+ const specifiedMaxCommands = constraints.maxCommands !== undefined;
+ const maxGeneratedCommands = (0, MaxLengthFromMinLength_1.maxGeneratedLengthFromSizeForArbitrary)(size, 0, maxCommands, specifiedMaxCommands);
+ return new CommandsArbitrary_1.CommandsArbitrary(commandArbs, maxGeneratedCommands, maxCommands, replayPath, disableReplayLog);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/compareBooleanFunc.js b/node_modules/fast-check/lib/arbitrary/compareBooleanFunc.js
new file mode 100644
index 0000000000000000000000000000000000000000..3ee3e19571208f8f526cf67149bbd9aef2dbc994
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/compareBooleanFunc.js
@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareBooleanFunc = compareBooleanFunc;
+const CompareFunctionArbitraryBuilder_1 = require("./_internals/builders/CompareFunctionArbitraryBuilder");
+const safeObjectAssign = Object.assign;
+function compareBooleanFunc() {
+ return (0, CompareFunctionArbitraryBuilder_1.buildCompareFunctionArbitrary)(safeObjectAssign((hA, hB) => hA < hB, {
+ toString() {
+ return '(hA, hB) => hA < hB';
+ },
+ }));
+}
diff --git a/node_modules/fast-check/lib/arbitrary/compareFunc.js b/node_modules/fast-check/lib/arbitrary/compareFunc.js
new file mode 100644
index 0000000000000000000000000000000000000000..aeb15d673570212a26bf9b9787a8d9b167936314
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/compareFunc.js
@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareFunc = compareFunc;
+const CompareFunctionArbitraryBuilder_1 = require("./_internals/builders/CompareFunctionArbitraryBuilder");
+const safeObjectAssign = Object.assign;
+function compareFunc() {
+ return (0, CompareFunctionArbitraryBuilder_1.buildCompareFunctionArbitrary)(safeObjectAssign((hA, hB) => hA - hB, {
+ toString() {
+ return '(hA, hB) => hA - hB';
+ },
+ }));
+}
diff --git a/node_modules/fast-check/lib/arbitrary/constant.js b/node_modules/fast-check/lib/arbitrary/constant.js
new file mode 100644
index 0000000000000000000000000000000000000000..210248aec2bc9672e38360914143a587cb109023
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/constant.js
@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.constant = constant;
+const ConstantArbitrary_1 = require("./_internals/ConstantArbitrary");
+function constant(value) {
+ return new ConstantArbitrary_1.ConstantArbitrary([value]);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/constantFrom.js b/node_modules/fast-check/lib/arbitrary/constantFrom.js
new file mode 100644
index 0000000000000000000000000000000000000000..90105464a3f912feedefc343f6bd5408da8fd1a3
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/constantFrom.js
@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.constantFrom = constantFrom;
+const ConstantArbitrary_1 = require("./_internals/ConstantArbitrary");
+function constantFrom(...values) {
+ if (values.length === 0) {
+ throw new Error('fc.constantFrom expects at least one parameter');
+ }
+ return new ConstantArbitrary_1.ConstantArbitrary(values);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/context.js b/node_modules/fast-check/lib/arbitrary/context.js
new file mode 100644
index 0000000000000000000000000000000000000000..71e2b9f07a5912a0b746ef90510fb939f231757d
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/context.js
@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.context = context;
+const symbols_1 = require("../check/symbols");
+const constant_1 = require("./constant");
+class ContextImplem {
+ constructor() {
+ this.receivedLogs = [];
+ }
+ log(data) {
+ this.receivedLogs.push(data);
+ }
+ size() {
+ return this.receivedLogs.length;
+ }
+ toString() {
+ return JSON.stringify({ logs: this.receivedLogs });
+ }
+ [symbols_1.cloneMethod]() {
+ return new ContextImplem();
+ }
+}
+function context() {
+ return (0, constant_1.constant)(new ContextImplem());
+}
diff --git a/node_modules/fast-check/lib/arbitrary/date.js b/node_modules/fast-check/lib/arbitrary/date.js
new file mode 100644
index 0000000000000000000000000000000000000000..14b90154154f256460972d9f93bb534980658f2d
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/date.js
@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.date = date;
+const globals_1 = require("../utils/globals");
+const integer_1 = require("./integer");
+const TimeToDate_1 = require("./_internals/mappers/TimeToDate");
+const safeNumberIsNaN = Number.isNaN;
+function date(constraints = {}) {
+ const intMin = constraints.min !== undefined ? (0, globals_1.safeGetTime)(constraints.min) : -8640000000000000;
+ const intMax = constraints.max !== undefined ? (0, globals_1.safeGetTime)(constraints.max) : 8640000000000000;
+ const noInvalidDate = constraints.noInvalidDate === undefined || constraints.noInvalidDate;
+ if (safeNumberIsNaN(intMin))
+ throw new Error('fc.date min must be valid instance of Date');
+ if (safeNumberIsNaN(intMax))
+ throw new Error('fc.date max must be valid instance of Date');
+ if (intMin > intMax)
+ throw new Error('fc.date max must be greater or equal to min');
+ if (noInvalidDate) {
+ return (0, integer_1.integer)({ min: intMin, max: intMax }).map(TimeToDate_1.timeToDateMapper, TimeToDate_1.timeToDateUnmapper);
+ }
+ const valueForNaN = intMax + 1;
+ return (0, integer_1.integer)({ min: intMin, max: intMax + 1 }).map((0, TimeToDate_1.timeToDateMapperWithNaN)(valueForNaN), (0, TimeToDate_1.timeToDateUnmapperWithNaN)(valueForNaN));
+}
diff --git a/node_modules/fast-check/lib/arbitrary/dictionary.js b/node_modules/fast-check/lib/arbitrary/dictionary.js
new file mode 100644
index 0000000000000000000000000000000000000000..19c9b1f6bef5df90171ef5c7c4dc0f69b3db82c3
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/dictionary.js
@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dictionary = dictionary;
+const tuple_1 = require("./tuple");
+const uniqueArray_1 = require("./uniqueArray");
+const KeyValuePairsToObject_1 = require("./_internals/mappers/KeyValuePairsToObject");
+const constant_1 = require("./constant");
+const boolean_1 = require("./boolean");
+function dictionaryKeyExtractor(entry) {
+ return entry[0];
+}
+function dictionary(keyArb, valueArb, constraints = {}) {
+ const noNullPrototype = constraints.noNullPrototype !== false;
+ return (0, tuple_1.tuple)((0, uniqueArray_1.uniqueArray)((0, tuple_1.tuple)(keyArb, valueArb), {
+ minLength: constraints.minKeys,
+ maxLength: constraints.maxKeys,
+ size: constraints.size,
+ selector: dictionaryKeyExtractor,
+ depthIdentifier: constraints.depthIdentifier,
+ }), noNullPrototype ? (0, constant_1.constant)(false) : (0, boolean_1.boolean)()).map(KeyValuePairsToObject_1.keyValuePairsToObjectMapper, KeyValuePairsToObject_1.keyValuePairsToObjectUnmapper);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/domain.js b/node_modules/fast-check/lib/arbitrary/domain.js
new file mode 100644
index 0000000000000000000000000000000000000000..b778d3db72e26e51978c629611cc219044eafdde
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/domain.js
@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.domain = domain;
+const array_1 = require("./array");
+const CharacterRangeArbitraryBuilder_1 = require("./_internals/builders/CharacterRangeArbitraryBuilder");
+const option_1 = require("./option");
+const string_1 = require("./string");
+const tuple_1 = require("./tuple");
+const InvalidSubdomainLabelFiIter_1 = require("./_internals/helpers/InvalidSubdomainLabelFiIter");
+const MaxLengthFromMinLength_1 = require("./_internals/helpers/MaxLengthFromMinLength");
+const AdapterArbitrary_1 = require("./_internals/AdapterArbitrary");
+const globals_1 = require("../utils/globals");
+function toSubdomainLabelMapper([f, d]) {
+ return d === null ? f : `${f}${d[0]}${d[1]}`;
+}
+function toSubdomainLabelUnmapper(value) {
+ if (typeof value !== 'string' || value.length === 0) {
+ throw new Error('Unsupported');
+ }
+ if (value.length === 1) {
+ return [value[0], null];
+ }
+ return [value[0], [(0, globals_1.safeSubstring)(value, 1, value.length - 1), value[value.length - 1]]];
+}
+function subdomainLabel(size) {
+ const alphaNumericArb = (0, CharacterRangeArbitraryBuilder_1.getOrCreateLowerAlphaNumericArbitrary)('');
+ const alphaNumericHyphenArb = (0, CharacterRangeArbitraryBuilder_1.getOrCreateLowerAlphaNumericArbitrary)('-');
+ return (0, tuple_1.tuple)(alphaNumericArb, (0, option_1.option)((0, tuple_1.tuple)((0, string_1.string)({ unit: alphaNumericHyphenArb, size, maxLength: 61 }), alphaNumericArb)))
+ .map(toSubdomainLabelMapper, toSubdomainLabelUnmapper)
+ .filter(InvalidSubdomainLabelFiIter_1.filterInvalidSubdomainLabel);
+}
+function labelsMapper(elements) {
+ return `${(0, globals_1.safeJoin)(elements[0], '.')}.${elements[1]}`;
+}
+function labelsUnmapper(value) {
+ if (typeof value !== 'string') {
+ throw new Error('Unsupported type');
+ }
+ const lastDotIndex = value.lastIndexOf('.');
+ return [(0, globals_1.safeSplit)((0, globals_1.safeSubstring)(value, 0, lastDotIndex), '.'), (0, globals_1.safeSubstring)(value, lastDotIndex + 1)];
+}
+function labelsAdapter(labels) {
+ const [subDomains, suffix] = labels;
+ let lengthNotIncludingIndex = suffix.length;
+ for (let index = 0; index !== subDomains.length; ++index) {
+ lengthNotIncludingIndex += 1 + subDomains[index].length;
+ if (lengthNotIncludingIndex > 255) {
+ return { adapted: true, value: [(0, globals_1.safeSlice)(subDomains, 0, index), suffix] };
+ }
+ }
+ return { adapted: false, value: labels };
+}
+function domain(constraints = {}) {
+ const resolvedSize = (0, MaxLengthFromMinLength_1.resolveSize)(constraints.size);
+ const resolvedSizeMinusOne = (0, MaxLengthFromMinLength_1.relativeSizeToSize)('-1', resolvedSize);
+ const lowerAlphaArb = (0, CharacterRangeArbitraryBuilder_1.getOrCreateLowerAlphaArbitrary)();
+ const publicSuffixArb = (0, string_1.string)({ unit: lowerAlphaArb, minLength: 2, maxLength: 63, size: resolvedSizeMinusOne });
+ return ((0, AdapterArbitrary_1.adapter)((0, tuple_1.tuple)((0, array_1.array)(subdomainLabel(resolvedSize), { size: resolvedSizeMinusOne, minLength: 1, maxLength: 127 }), publicSuffixArb), labelsAdapter).map(labelsMapper, labelsUnmapper));
+}
diff --git a/node_modules/fast-check/lib/arbitrary/double.js b/node_modules/fast-check/lib/arbitrary/double.js
new file mode 100644
index 0000000000000000000000000000000000000000..61d7e6cb43b62985d1743e62d8ad441b6f7f91de
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/double.js
@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.double = double;
+const ArrayInt64_1 = require("./_internals/helpers/ArrayInt64");
+const ArrayInt64Arbitrary_1 = require("./_internals/ArrayInt64Arbitrary");
+const DoubleHelpers_1 = require("./_internals/helpers/DoubleHelpers");
+const DoubleOnlyHelpers_1 = require("./_internals/helpers/DoubleOnlyHelpers");
+const safeNumberIsInteger = Number.isInteger;
+const safeNumberIsNaN = Number.isNaN;
+const safeNegativeInfinity = Number.NEGATIVE_INFINITY;
+const safePositiveInfinity = Number.POSITIVE_INFINITY;
+const safeMaxValue = Number.MAX_VALUE;
+const safeNaN = Number.NaN;
+function safeDoubleToIndex(d, constraintsLabel) {
+ if (safeNumberIsNaN(d)) {
+ throw new Error('fc.double constraints.' + constraintsLabel + ' must be a 64-bit float');
+ }
+ return (0, DoubleHelpers_1.doubleToIndex)(d);
+}
+function unmapperDoubleToIndex(value) {
+ if (typeof value !== 'number')
+ throw new Error('Unsupported type');
+ return (0, DoubleHelpers_1.doubleToIndex)(value);
+}
+function numberIsNotInteger(value) {
+ return !safeNumberIsInteger(value);
+}
+function anyDouble(constraints) {
+ const { noDefaultInfinity = false, noNaN = false, minExcluded = false, maxExcluded = false, min = noDefaultInfinity ? -safeMaxValue : safeNegativeInfinity, max = noDefaultInfinity ? safeMaxValue : safePositiveInfinity, } = constraints;
+ const minIndexRaw = safeDoubleToIndex(min, 'min');
+ const minIndex = minExcluded ? (0, ArrayInt64_1.add64)(minIndexRaw, ArrayInt64_1.Unit64) : minIndexRaw;
+ const maxIndexRaw = safeDoubleToIndex(max, 'max');
+ const maxIndex = maxExcluded ? (0, ArrayInt64_1.substract64)(maxIndexRaw, ArrayInt64_1.Unit64) : maxIndexRaw;
+ if ((0, ArrayInt64_1.isStrictlySmaller64)(maxIndex, minIndex)) {
+ throw new Error('fc.double constraints.min must be smaller or equal to constraints.max');
+ }
+ if (noNaN) {
+ return (0, ArrayInt64Arbitrary_1.arrayInt64)(minIndex, maxIndex).map(DoubleHelpers_1.indexToDouble, unmapperDoubleToIndex);
+ }
+ const positiveMaxIdx = (0, ArrayInt64_1.isStrictlyPositive64)(maxIndex);
+ const minIndexWithNaN = positiveMaxIdx ? minIndex : (0, ArrayInt64_1.substract64)(minIndex, ArrayInt64_1.Unit64);
+ const maxIndexWithNaN = positiveMaxIdx ? (0, ArrayInt64_1.add64)(maxIndex, ArrayInt64_1.Unit64) : maxIndex;
+ return (0, ArrayInt64Arbitrary_1.arrayInt64)(minIndexWithNaN, maxIndexWithNaN).map((index) => {
+ if ((0, ArrayInt64_1.isStrictlySmaller64)(maxIndex, index) || (0, ArrayInt64_1.isStrictlySmaller64)(index, minIndex))
+ return safeNaN;
+ else
+ return (0, DoubleHelpers_1.indexToDouble)(index);
+ }, (value) => {
+ if (typeof value !== 'number')
+ throw new Error('Unsupported type');
+ if (safeNumberIsNaN(value))
+ return !(0, ArrayInt64_1.isEqual64)(maxIndex, maxIndexWithNaN) ? maxIndexWithNaN : minIndexWithNaN;
+ return (0, DoubleHelpers_1.doubleToIndex)(value);
+ });
+}
+function double(constraints = {}) {
+ if (!constraints.noInteger) {
+ return anyDouble(constraints);
+ }
+ return anyDouble((0, DoubleOnlyHelpers_1.refineConstraintsForDoubleOnly)(constraints))
+ .map(DoubleOnlyHelpers_1.doubleOnlyMapper, DoubleOnlyHelpers_1.doubleOnlyUnmapper)
+ .filter(numberIsNotInteger);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/emailAddress.js b/node_modules/fast-check/lib/arbitrary/emailAddress.js
new file mode 100644
index 0000000000000000000000000000000000000000..24323fbff9dec3b15237e503197d5e41458bd1f7
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/emailAddress.js
@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emailAddress = emailAddress;
+const array_1 = require("./array");
+const CharacterRangeArbitraryBuilder_1 = require("./_internals/builders/CharacterRangeArbitraryBuilder");
+const domain_1 = require("./domain");
+const string_1 = require("./string");
+const tuple_1 = require("./tuple");
+const AdapterArbitrary_1 = require("./_internals/AdapterArbitrary");
+const globals_1 = require("../utils/globals");
+function dotAdapter(a) {
+ let currentLength = a[0].length;
+ for (let index = 1; index !== a.length; ++index) {
+ currentLength += 1 + a[index].length;
+ if (currentLength > 64) {
+ return { adapted: true, value: (0, globals_1.safeSlice)(a, 0, index) };
+ }
+ }
+ return { adapted: false, value: a };
+}
+function dotMapper(a) {
+ return (0, globals_1.safeJoin)(a, '.');
+}
+function dotUnmapper(value) {
+ if (typeof value !== 'string') {
+ throw new Error('Unsupported');
+ }
+ return (0, globals_1.safeSplit)(value, '.');
+}
+function atMapper(data) {
+ return `${data[0]}@${data[1]}`;
+}
+function atUnmapper(value) {
+ if (typeof value !== 'string') {
+ throw new Error('Unsupported');
+ }
+ return (0, globals_1.safeSplit)(value, '@', 2);
+}
+function emailAddress(constraints = {}) {
+ const atextArb = (0, CharacterRangeArbitraryBuilder_1.getOrCreateLowerAlphaNumericArbitrary)("!#$%&'*+-/=?^_`{|}~");
+ const localPartArb = (0, AdapterArbitrary_1.adapter)((0, array_1.array)((0, string_1.string)({
+ unit: atextArb,
+ minLength: 1,
+ maxLength: 64,
+ size: constraints.size,
+ }), { minLength: 1, maxLength: 32, size: constraints.size }), dotAdapter).map(dotMapper, dotUnmapper);
+ return (0, tuple_1.tuple)(localPartArb, (0, domain_1.domain)({ size: constraints.size })).map(atMapper, atUnmapper);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/falsy.js b/node_modules/fast-check/lib/arbitrary/falsy.js
new file mode 100644
index 0000000000000000000000000000000000000000..0d9bd964ee93c145b231bffe507a0b20c4f746ab
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/falsy.js
@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.falsy = falsy;
+const globals_1 = require("../utils/globals");
+const constantFrom_1 = require("./constantFrom");
+function falsy(constraints) {
+ if (!constraints || !constraints.withBigInt) {
+ return (0, constantFrom_1.constantFrom)(false, null, undefined, 0, '', NaN);
+ }
+ return (0, constantFrom_1.constantFrom)(false, null, undefined, 0, '', NaN, (0, globals_1.BigInt)(0));
+}
diff --git a/node_modules/fast-check/lib/arbitrary/float.js b/node_modules/fast-check/lib/arbitrary/float.js
new file mode 100644
index 0000000000000000000000000000000000000000..daa03777d8368509eb2a971b06c7684876924ff8
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/float.js
@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.float = float;
+const integer_1 = require("./integer");
+const FloatHelpers_1 = require("./_internals/helpers/FloatHelpers");
+const FloatOnlyHelpers_1 = require("./_internals/helpers/FloatOnlyHelpers");
+const safeNumberIsInteger = Number.isInteger;
+const safeNumberIsNaN = Number.isNaN;
+const safeMathFround = Math.fround;
+const safeNegativeInfinity = Number.NEGATIVE_INFINITY;
+const safePositiveInfinity = Number.POSITIVE_INFINITY;
+const safeNaN = Number.NaN;
+function safeFloatToIndex(f, constraintsLabel) {
+ const conversionTrick = 'you can convert any double to a 32-bit float by using `Math.fround(myDouble)`';
+ const errorMessage = 'fc.float constraints.' + constraintsLabel + ' must be a 32-bit float - ' + conversionTrick;
+ if (safeNumberIsNaN(f) || safeMathFround(f) !== f) {
+ throw new Error(errorMessage);
+ }
+ return (0, FloatHelpers_1.floatToIndex)(f);
+}
+function unmapperFloatToIndex(value) {
+ if (typeof value !== 'number')
+ throw new Error('Unsupported type');
+ return (0, FloatHelpers_1.floatToIndex)(value);
+}
+function numberIsNotInteger(value) {
+ return !safeNumberIsInteger(value);
+}
+function anyFloat(constraints) {
+ const { noDefaultInfinity = false, noNaN = false, minExcluded = false, maxExcluded = false, min = noDefaultInfinity ? -FloatHelpers_1.MAX_VALUE_32 : safeNegativeInfinity, max = noDefaultInfinity ? FloatHelpers_1.MAX_VALUE_32 : safePositiveInfinity, } = constraints;
+ const minIndexRaw = safeFloatToIndex(min, 'min');
+ const minIndex = minExcluded ? minIndexRaw + 1 : minIndexRaw;
+ const maxIndexRaw = safeFloatToIndex(max, 'max');
+ const maxIndex = maxExcluded ? maxIndexRaw - 1 : maxIndexRaw;
+ if (minIndex > maxIndex) {
+ throw new Error('fc.float constraints.min must be smaller or equal to constraints.max');
+ }
+ if (noNaN) {
+ return (0, integer_1.integer)({ min: minIndex, max: maxIndex }).map(FloatHelpers_1.indexToFloat, unmapperFloatToIndex);
+ }
+ const minIndexWithNaN = maxIndex > 0 ? minIndex : minIndex - 1;
+ const maxIndexWithNaN = maxIndex > 0 ? maxIndex + 1 : maxIndex;
+ return (0, integer_1.integer)({ min: minIndexWithNaN, max: maxIndexWithNaN }).map((index) => {
+ if (index > maxIndex || index < minIndex)
+ return safeNaN;
+ else
+ return (0, FloatHelpers_1.indexToFloat)(index);
+ }, (value) => {
+ if (typeof value !== 'number')
+ throw new Error('Unsupported type');
+ if (safeNumberIsNaN(value))
+ return maxIndex !== maxIndexWithNaN ? maxIndexWithNaN : minIndexWithNaN;
+ return (0, FloatHelpers_1.floatToIndex)(value);
+ });
+}
+function float(constraints = {}) {
+ if (!constraints.noInteger) {
+ return anyFloat(constraints);
+ }
+ return anyFloat((0, FloatOnlyHelpers_1.refineConstraintsForFloatOnly)(constraints))
+ .map(FloatOnlyHelpers_1.floatOnlyMapper, FloatOnlyHelpers_1.floatOnlyUnmapper)
+ .filter(numberIsNotInteger);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/float32Array.js b/node_modules/fast-check/lib/arbitrary/float32Array.js
new file mode 100644
index 0000000000000000000000000000000000000000..22e13b0020c1ee6702e2f0af21bd0e35a1c527c4
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/float32Array.js
@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.float32Array = float32Array;
+const float_1 = require("./float");
+const array_1 = require("./array");
+const globals_1 = require("../utils/globals");
+function toTypedMapper(data) {
+ return globals_1.Float32Array.from(data);
+}
+function fromTypedUnmapper(value) {
+ if (!(value instanceof globals_1.Float32Array))
+ throw new Error('Unexpected type');
+ return [...value];
+}
+function float32Array(constraints = {}) {
+ return (0, array_1.array)((0, float_1.float)(constraints), constraints).map(toTypedMapper, fromTypedUnmapper);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/float64Array.js b/node_modules/fast-check/lib/arbitrary/float64Array.js
new file mode 100644
index 0000000000000000000000000000000000000000..238d46d32672b6867639857cddf236ca613ab916
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/float64Array.js
@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.float64Array = float64Array;
+const double_1 = require("./double");
+const array_1 = require("./array");
+const globals_1 = require("../utils/globals");
+function toTypedMapper(data) {
+ return globals_1.Float64Array.from(data);
+}
+function fromTypedUnmapper(value) {
+ if (!(value instanceof globals_1.Float64Array))
+ throw new Error('Unexpected type');
+ return [...value];
+}
+function float64Array(constraints = {}) {
+ return (0, array_1.array)((0, double_1.double)(constraints), constraints).map(toTypedMapper, fromTypedUnmapper);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/fullUnicode.js b/node_modules/fast-check/lib/arbitrary/fullUnicode.js
new file mode 100644
index 0000000000000000000000000000000000000000..0889ee43dadb39bb936fb4d95f86d27e535be530
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/fullUnicode.js
@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fullUnicode = fullUnicode;
+const CharacterArbitraryBuilder_1 = require("./_internals/builders/CharacterArbitraryBuilder");
+const IndexToPrintableIndex_1 = require("./_internals/mappers/IndexToPrintableIndex");
+const gapSize = 0xdfff + 1 - 0xd800;
+function unicodeMapper(v) {
+ if (v < 0xd800)
+ return (0, IndexToPrintableIndex_1.indexToPrintableIndexMapper)(v);
+ return v + gapSize;
+}
+function unicodeUnmapper(v) {
+ if (v < 0xd800)
+ return (0, IndexToPrintableIndex_1.indexToPrintableIndexUnmapper)(v);
+ if (v <= 0xdfff)
+ return -1;
+ return v - gapSize;
+}
+function fullUnicode() {
+ return (0, CharacterArbitraryBuilder_1.buildCharacterArbitrary)(0x0000, 0x10ffff - gapSize, unicodeMapper, unicodeUnmapper);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/fullUnicodeString.js b/node_modules/fast-check/lib/arbitrary/fullUnicodeString.js
new file mode 100644
index 0000000000000000000000000000000000000000..2237dfa5493b13a195475918aa7a53710bdcbd03
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/fullUnicodeString.js
@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fullUnicodeString = fullUnicodeString;
+const array_1 = require("./array");
+const fullUnicode_1 = require("./fullUnicode");
+const CodePointsToString_1 = require("./_internals/mappers/CodePointsToString");
+const SlicesForStringBuilder_1 = require("./_internals/helpers/SlicesForStringBuilder");
+const safeObjectAssign = Object.assign;
+function fullUnicodeString(constraints = {}) {
+ const charArbitrary = (0, fullUnicode_1.fullUnicode)();
+ const experimentalCustomSlices = (0, SlicesForStringBuilder_1.createSlicesForStringLegacy)(charArbitrary, CodePointsToString_1.codePointsToStringUnmapper);
+ const enrichedConstraints = safeObjectAssign(safeObjectAssign({}, constraints), {
+ experimentalCustomSlices,
+ });
+ return (0, array_1.array)(charArbitrary, enrichedConstraints).map(CodePointsToString_1.codePointsToStringMapper, CodePointsToString_1.codePointsToStringUnmapper);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/func.js b/node_modules/fast-check/lib/arbitrary/func.js
new file mode 100644
index 0000000000000000000000000000000000000000..68f7950a316cbbdebba68b1a457642c882121e92
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/func.js
@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.func = func;
+const hash_1 = require("../utils/hash");
+const stringify_1 = require("../utils/stringify");
+const symbols_1 = require("../check/symbols");
+const array_1 = require("./array");
+const integer_1 = require("./integer");
+const noShrink_1 = require("./noShrink");
+const tuple_1 = require("./tuple");
+const TextEscaper_1 = require("./_internals/helpers/TextEscaper");
+const globals_1 = require("../utils/globals");
+const safeObjectDefineProperties = Object.defineProperties;
+const safeObjectKeys = Object.keys;
+function func(arb) {
+ return (0, tuple_1.tuple)((0, array_1.array)(arb, { minLength: 1 }), (0, noShrink_1.noShrink)((0, integer_1.integer)())).map(([outs, seed]) => {
+ const producer = () => {
+ const recorded = {};
+ const f = (...args) => {
+ const repr = (0, stringify_1.stringify)(args);
+ const val = outs[(0, hash_1.hash)(`${seed}${repr}`) % outs.length];
+ recorded[repr] = val;
+ return (0, symbols_1.hasCloneMethod)(val) ? val[symbols_1.cloneMethod]() : val;
+ };
+ function prettyPrint(stringifiedOuts) {
+ const seenValues = (0, globals_1.safeMap)((0, globals_1.safeMap)((0, globals_1.safeSort)(safeObjectKeys(recorded)), (k) => `${k} => ${(0, stringify_1.stringify)(recorded[k])}`), (line) => `/* ${(0, TextEscaper_1.escapeForMultilineComments)(line)} */`);
+ return `function(...args) {
+ // With hash and stringify coming from fast-check${seenValues.length !== 0 ? `\n ${seenValues.join('\n ')}` : ''}
+ const outs = ${stringifiedOuts};
+ return outs[hash('${seed}' + stringify(args)) % outs.length];
+}`;
+ }
+ return safeObjectDefineProperties(f, {
+ toString: { value: () => prettyPrint((0, stringify_1.stringify)(outs)) },
+ [stringify_1.toStringMethod]: { value: () => prettyPrint((0, stringify_1.stringify)(outs)) },
+ [stringify_1.asyncToStringMethod]: { value: async () => prettyPrint(await (0, stringify_1.asyncStringify)(outs)) },
+ [symbols_1.cloneMethod]: { value: producer, configurable: true },
+ });
+ };
+ return producer();
+ });
+}
diff --git a/node_modules/fast-check/lib/arbitrary/gen.js b/node_modules/fast-check/lib/arbitrary/gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..1347281a1a1922a8c1fb64bc57d71287fe546e29
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/gen.js
@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gen = gen;
+const GeneratorArbitrary_1 = require("./_internals/GeneratorArbitrary");
+function gen() {
+ return new GeneratorArbitrary_1.GeneratorArbitrary();
+}
diff --git a/node_modules/fast-check/lib/arbitrary/hexa.js b/node_modules/fast-check/lib/arbitrary/hexa.js
new file mode 100644
index 0000000000000000000000000000000000000000..0ed6a5aa7d6fd17c1147ca4df221c6de1a39bf0d
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/hexa.js
@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hexa = hexa;
+const CharacterArbitraryBuilder_1 = require("./_internals/builders/CharacterArbitraryBuilder");
+function hexaMapper(v) {
+ return v < 10
+ ? v + 48
+ : v + 97 - 10;
+}
+function hexaUnmapper(v) {
+ return v < 58
+ ? v - 48
+ : v >= 97 && v < 103
+ ? v - 97 + 10
+ : -1;
+}
+function hexa() {
+ return (0, CharacterArbitraryBuilder_1.buildCharacterArbitrary)(0, 15, hexaMapper, hexaUnmapper);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/hexaString.js b/node_modules/fast-check/lib/arbitrary/hexaString.js
new file mode 100644
index 0000000000000000000000000000000000000000..4ceaeebbeb382578263cf0d80bb7f5fa957cd5b2
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/hexaString.js
@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hexaString = hexaString;
+const array_1 = require("./array");
+const hexa_1 = require("./hexa");
+const CodePointsToString_1 = require("./_internals/mappers/CodePointsToString");
+const SlicesForStringBuilder_1 = require("./_internals/helpers/SlicesForStringBuilder");
+const safeObjectAssign = Object.assign;
+function hexaString(constraints = {}) {
+ const charArbitrary = (0, hexa_1.hexa)();
+ const experimentalCustomSlices = (0, SlicesForStringBuilder_1.createSlicesForStringLegacy)(charArbitrary, CodePointsToString_1.codePointsToStringUnmapper);
+ const enrichedConstraints = safeObjectAssign(safeObjectAssign({}, constraints), {
+ experimentalCustomSlices,
+ });
+ return (0, array_1.array)(charArbitrary, enrichedConstraints).map(CodePointsToString_1.codePointsToStringMapper, CodePointsToString_1.codePointsToStringUnmapper);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/infiniteStream.js b/node_modules/fast-check/lib/arbitrary/infiniteStream.js
new file mode 100644
index 0000000000000000000000000000000000000000..f0e21ab094b68dd21dc97f36fd0e3bafc5dc322c
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/infiniteStream.js
@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.infiniteStream = infiniteStream;
+const StreamArbitrary_1 = require("./_internals/StreamArbitrary");
+function infiniteStream(arb) {
+ return new StreamArbitrary_1.StreamArbitrary(arb);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/int16Array.js b/node_modules/fast-check/lib/arbitrary/int16Array.js
new file mode 100644
index 0000000000000000000000000000000000000000..934ee2919a2cd0687427ed53fa4cfe9546970d2b
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/int16Array.js
@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.int16Array = int16Array;
+const globals_1 = require("../utils/globals");
+const integer_1 = require("./integer");
+const TypedIntArrayArbitraryBuilder_1 = require("./_internals/builders/TypedIntArrayArbitraryBuilder");
+function int16Array(constraints = {}) {
+ return (0, TypedIntArrayArbitraryBuilder_1.typedIntArrayArbitraryArbitraryBuilder)(constraints, -32768, 32767, globals_1.Int16Array, integer_1.integer);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/int32Array.js b/node_modules/fast-check/lib/arbitrary/int32Array.js
new file mode 100644
index 0000000000000000000000000000000000000000..b88383823da8eb79966f2cda597dba25b0db9d6f
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/int32Array.js
@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.int32Array = int32Array;
+const globals_1 = require("../utils/globals");
+const integer_1 = require("./integer");
+const TypedIntArrayArbitraryBuilder_1 = require("./_internals/builders/TypedIntArrayArbitraryBuilder");
+function int32Array(constraints = {}) {
+ return (0, TypedIntArrayArbitraryBuilder_1.typedIntArrayArbitraryArbitraryBuilder)(constraints, -0x80000000, 0x7fffffff, globals_1.Int32Array, integer_1.integer);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/int8Array.js b/node_modules/fast-check/lib/arbitrary/int8Array.js
new file mode 100644
index 0000000000000000000000000000000000000000..5dc0069d6307477f71bb46beddaec7fc3de17e67
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/int8Array.js
@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.int8Array = int8Array;
+const globals_1 = require("../utils/globals");
+const integer_1 = require("./integer");
+const TypedIntArrayArbitraryBuilder_1 = require("./_internals/builders/TypedIntArrayArbitraryBuilder");
+function int8Array(constraints = {}) {
+ return (0, TypedIntArrayArbitraryBuilder_1.typedIntArrayArbitraryArbitraryBuilder)(constraints, -128, 127, globals_1.Int8Array, integer_1.integer);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/integer.js b/node_modules/fast-check/lib/arbitrary/integer.js
new file mode 100644
index 0000000000000000000000000000000000000000..b3a2541fa594fafe7056744223ee91611a5bc9f5
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/integer.js
@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.integer = integer;
+const IntegerArbitrary_1 = require("./_internals/IntegerArbitrary");
+const safeNumberIsInteger = Number.isInteger;
+function buildCompleteIntegerConstraints(constraints) {
+ const min = constraints.min !== undefined ? constraints.min : -0x80000000;
+ const max = constraints.max !== undefined ? constraints.max : 0x7fffffff;
+ return { min, max };
+}
+function integer(constraints = {}) {
+ const fullConstraints = buildCompleteIntegerConstraints(constraints);
+ if (fullConstraints.min > fullConstraints.max) {
+ throw new Error('fc.integer maximum value should be equal or greater than the minimum one');
+ }
+ if (!safeNumberIsInteger(fullConstraints.min)) {
+ throw new Error('fc.integer minimum value should be an integer');
+ }
+ if (!safeNumberIsInteger(fullConstraints.max)) {
+ throw new Error('fc.integer maximum value should be an integer');
+ }
+ return new IntegerArbitrary_1.IntegerArbitrary(fullConstraints.min, fullConstraints.max);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/ipV4.js b/node_modules/fast-check/lib/arbitrary/ipV4.js
new file mode 100644
index 0000000000000000000000000000000000000000..1d4a819a1cb54b9f2a4380f06f388b0aa567fac7
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/ipV4.js
@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ipV4 = ipV4;
+const globals_1 = require("../utils/globals");
+const nat_1 = require("./nat");
+const tuple_1 = require("./tuple");
+const NatToStringifiedNat_1 = require("./_internals/mappers/NatToStringifiedNat");
+function dotJoinerMapper(data) {
+ return (0, globals_1.safeJoin)(data, '.');
+}
+function dotJoinerUnmapper(value) {
+ if (typeof value !== 'string') {
+ throw new Error('Invalid type');
+ }
+ return (0, globals_1.safeMap)((0, globals_1.safeSplit)(value, '.'), (v) => (0, NatToStringifiedNat_1.tryParseStringifiedNat)(v, 10));
+}
+function ipV4() {
+ return (0, tuple_1.tuple)((0, nat_1.nat)(255), (0, nat_1.nat)(255), (0, nat_1.nat)(255), (0, nat_1.nat)(255)).map(dotJoinerMapper, dotJoinerUnmapper);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/ipV4Extended.js b/node_modules/fast-check/lib/arbitrary/ipV4Extended.js
new file mode 100644
index 0000000000000000000000000000000000000000..74bec075ee8827ae57a9216dbf7d24e3024474a9
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/ipV4Extended.js
@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ipV4Extended = ipV4Extended;
+const globals_1 = require("../utils/globals");
+const oneof_1 = require("./oneof");
+const tuple_1 = require("./tuple");
+const StringifiedNatArbitraryBuilder_1 = require("./_internals/builders/StringifiedNatArbitraryBuilder");
+function dotJoinerMapper(data) {
+ return (0, globals_1.safeJoin)(data, '.');
+}
+function dotJoinerUnmapper(value) {
+ if (typeof value !== 'string') {
+ throw new Error('Invalid type');
+ }
+ return (0, globals_1.safeSplit)(value, '.');
+}
+function ipV4Extended() {
+ return (0, oneof_1.oneof)((0, tuple_1.tuple)((0, StringifiedNatArbitraryBuilder_1.buildStringifiedNatArbitrary)(255), (0, StringifiedNatArbitraryBuilder_1.buildStringifiedNatArbitrary)(255), (0, StringifiedNatArbitraryBuilder_1.buildStringifiedNatArbitrary)(255), (0, StringifiedNatArbitraryBuilder_1.buildStringifiedNatArbitrary)(255)).map(dotJoinerMapper, dotJoinerUnmapper), (0, tuple_1.tuple)((0, StringifiedNatArbitraryBuilder_1.buildStringifiedNatArbitrary)(255), (0, StringifiedNatArbitraryBuilder_1.buildStringifiedNatArbitrary)(255), (0, StringifiedNatArbitraryBuilder_1.buildStringifiedNatArbitrary)(65535)).map(dotJoinerMapper, dotJoinerUnmapper), (0, tuple_1.tuple)((0, StringifiedNatArbitraryBuilder_1.buildStringifiedNatArbitrary)(255), (0, StringifiedNatArbitraryBuilder_1.buildStringifiedNatArbitrary)(16777215)).map(dotJoinerMapper, dotJoinerUnmapper), (0, StringifiedNatArbitraryBuilder_1.buildStringifiedNatArbitrary)(4294967295));
+}
diff --git a/node_modules/fast-check/lib/arbitrary/ipV6.js b/node_modules/fast-check/lib/arbitrary/ipV6.js
new file mode 100644
index 0000000000000000000000000000000000000000..0c3c184a2653e55db817733c65a3c09b538b433e
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/ipV6.js
@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ipV6 = ipV6;
+const array_1 = require("./array");
+const oneof_1 = require("./oneof");
+const hexaString_1 = require("./hexaString");
+const tuple_1 = require("./tuple");
+const ipV4_1 = require("./ipV4");
+const EntitiesToIPv6_1 = require("./_internals/mappers/EntitiesToIPv6");
+function h16sTol32Mapper([a, b]) {
+ return `${a}:${b}`;
+}
+function h16sTol32Unmapper(value) {
+ if (typeof value !== 'string')
+ throw new Error('Invalid type');
+ if (!value.includes(':'))
+ throw new Error('Invalid value');
+ return value.split(':', 2);
+}
+function ipV6() {
+ const h16Arb = (0, hexaString_1.hexaString)({ minLength: 1, maxLength: 4, size: 'max' });
+ const ls32Arb = (0, oneof_1.oneof)((0, tuple_1.tuple)(h16Arb, h16Arb).map(h16sTol32Mapper, h16sTol32Unmapper), (0, ipV4_1.ipV4)());
+ return (0, oneof_1.oneof)((0, tuple_1.tuple)((0, array_1.array)(h16Arb, { minLength: 6, maxLength: 6, size: 'max' }), ls32Arb).map(EntitiesToIPv6_1.fullySpecifiedMapper, EntitiesToIPv6_1.fullySpecifiedUnmapper), (0, tuple_1.tuple)((0, array_1.array)(h16Arb, { minLength: 5, maxLength: 5, size: 'max' }), ls32Arb).map(EntitiesToIPv6_1.onlyTrailingMapper, EntitiesToIPv6_1.onlyTrailingUnmapper), (0, tuple_1.tuple)((0, array_1.array)(h16Arb, { minLength: 0, maxLength: 1, size: 'max' }), (0, array_1.array)(h16Arb, { minLength: 4, maxLength: 4, size: 'max' }), ls32Arb).map(EntitiesToIPv6_1.multiTrailingMapper, EntitiesToIPv6_1.multiTrailingUnmapper), (0, tuple_1.tuple)((0, array_1.array)(h16Arb, { minLength: 0, maxLength: 2, size: 'max' }), (0, array_1.array)(h16Arb, { minLength: 3, maxLength: 3, size: 'max' }), ls32Arb).map(EntitiesToIPv6_1.multiTrailingMapper, EntitiesToIPv6_1.multiTrailingUnmapper), (0, tuple_1.tuple)((0, array_1.array)(h16Arb, { minLength: 0, maxLength: 3, size: 'max' }), (0, array_1.array)(h16Arb, { minLength: 2, maxLength: 2, size: 'max' }), ls32Arb).map(EntitiesToIPv6_1.multiTrailingMapper, EntitiesToIPv6_1.multiTrailingUnmapper), (0, tuple_1.tuple)((0, array_1.array)(h16Arb, { minLength: 0, maxLength: 4, size: 'max' }), h16Arb, ls32Arb).map(EntitiesToIPv6_1.multiTrailingMapperOne, EntitiesToIPv6_1.multiTrailingUnmapperOne), (0, tuple_1.tuple)((0, array_1.array)(h16Arb, { minLength: 0, maxLength: 5, size: 'max' }), ls32Arb).map(EntitiesToIPv6_1.singleTrailingMapper, EntitiesToIPv6_1.singleTrailingUnmapper), (0, tuple_1.tuple)((0, array_1.array)(h16Arb, { minLength: 0, maxLength: 6, size: 'max' }), h16Arb).map(EntitiesToIPv6_1.singleTrailingMapper, EntitiesToIPv6_1.singleTrailingUnmapper), (0, tuple_1.tuple)((0, array_1.array)(h16Arb, { minLength: 0, maxLength: 7, size: 'max' })).map(EntitiesToIPv6_1.noTrailingMapper, EntitiesToIPv6_1.noTrailingUnmapper));
+}
diff --git a/node_modules/fast-check/lib/arbitrary/json.js b/node_modules/fast-check/lib/arbitrary/json.js
new file mode 100644
index 0000000000000000000000000000000000000000..37f798f6de3a6fd79200006f199c7f1dacae119c
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/json.js
@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.json = json;
+const jsonValue_1 = require("./jsonValue");
+function json(constraints = {}) {
+ const arb = (0, jsonValue_1.jsonValue)(constraints);
+ return arb.map(JSON.stringify);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/jsonValue.js b/node_modules/fast-check/lib/arbitrary/jsonValue.js
new file mode 100644
index 0000000000000000000000000000000000000000..05509362ffd315da96da4a72ee5b9c9d0713773f
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/jsonValue.js
@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsonValue = jsonValue;
+const string_1 = require("./string");
+const JsonConstraintsBuilder_1 = require("./_internals/helpers/JsonConstraintsBuilder");
+const anything_1 = require("./anything");
+const fullUnicodeString_1 = require("./fullUnicodeString");
+function jsonValue(constraints = {}) {
+ const noUnicodeString = constraints.noUnicodeString === undefined || constraints.noUnicodeString === true;
+ const stringArbitrary = 'stringUnit' in constraints
+ ? (0, string_1.string)({ unit: constraints.stringUnit })
+ : noUnicodeString
+ ? (0, string_1.string)()
+ : (0, fullUnicodeString_1.fullUnicodeString)();
+ return (0, anything_1.anything)((0, JsonConstraintsBuilder_1.jsonConstraintsBuilder)(stringArbitrary, constraints));
+}
diff --git a/node_modules/fast-check/lib/arbitrary/letrec.js b/node_modules/fast-check/lib/arbitrary/letrec.js
new file mode 100644
index 0000000000000000000000000000000000000000..138434d35b4ba6f312075d9d32aa3d0e14925c18
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/letrec.js
@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.letrec = letrec;
+const LazyArbitrary_1 = require("./_internals/LazyArbitrary");
+const globals_1 = require("../utils/globals");
+const safeObjectCreate = Object.create;
+function letrec(builder) {
+ const lazyArbs = safeObjectCreate(null);
+ const tie = (key) => {
+ if (!(0, globals_1.safeHasOwnProperty)(lazyArbs, key)) {
+ lazyArbs[key] = new LazyArbitrary_1.LazyArbitrary(String(key));
+ }
+ return lazyArbs[key];
+ };
+ const strictArbs = builder(tie);
+ for (const key in strictArbs) {
+ if (!(0, globals_1.safeHasOwnProperty)(strictArbs, key)) {
+ continue;
+ }
+ const lazyAtKey = lazyArbs[key];
+ const lazyArb = lazyAtKey !== undefined ? lazyAtKey : new LazyArbitrary_1.LazyArbitrary(key);
+ lazyArb.underlying = strictArbs[key];
+ lazyArbs[key] = lazyArb;
+ }
+ return strictArbs;
+}
diff --git a/node_modules/fast-check/lib/arbitrary/limitShrink.js b/node_modules/fast-check/lib/arbitrary/limitShrink.js
new file mode 100644
index 0000000000000000000000000000000000000000..f49f6b75429acbacbb691bfd37c6ea13f30e7407
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/limitShrink.js
@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.limitShrink = limitShrink;
+const LimitedShrinkArbitrary_1 = require("./_internals/LimitedShrinkArbitrary");
+function limitShrink(arbitrary, maxShrinks) {
+ return new LimitedShrinkArbitrary_1.LimitedShrinkArbitrary(arbitrary, maxShrinks);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/lorem.js b/node_modules/fast-check/lib/arbitrary/lorem.js
new file mode 100644
index 0000000000000000000000000000000000000000..512aaee91ec3f7023fe7d2b71d7600819bdf6dc7
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/lorem.js
@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lorem = lorem;
+const array_1 = require("./array");
+const constant_1 = require("./constant");
+const oneof_1 = require("./oneof");
+const WordsToLorem_1 = require("./_internals/mappers/WordsToLorem");
+const h = (v, w) => {
+ return { arbitrary: (0, constant_1.constant)(v), weight: w };
+};
+function loremWord() {
+ return (0, oneof_1.oneof)(h('non', 6), h('adipiscing', 5), h('ligula', 5), h('enim', 5), h('pellentesque', 5), h('in', 5), h('augue', 5), h('et', 5), h('nulla', 5), h('lorem', 4), h('sit', 4), h('sed', 4), h('diam', 4), h('fermentum', 4), h('ut', 4), h('eu', 4), h('aliquam', 4), h('mauris', 4), h('vitae', 4), h('felis', 4), h('ipsum', 3), h('dolor', 3), h('amet,', 3), h('elit', 3), h('euismod', 3), h('mi', 3), h('orci', 3), h('erat', 3), h('praesent', 3), h('egestas', 3), h('leo', 3), h('vel', 3), h('sapien', 3), h('integer', 3), h('curabitur', 3), h('convallis', 3), h('purus', 3), h('risus', 2), h('suspendisse', 2), h('lectus', 2), h('nec,', 2), h('ultricies', 2), h('sed,', 2), h('cras', 2), h('elementum', 2), h('ultrices', 2), h('maecenas', 2), h('massa,', 2), h('varius', 2), h('a,', 2), h('semper', 2), h('proin', 2), h('nec', 2), h('nisl', 2), h('amet', 2), h('duis', 2), h('congue', 2), h('libero', 2), h('vestibulum', 2), h('pede', 2), h('blandit', 2), h('sodales', 2), h('ante', 2), h('nibh', 2), h('ac', 2), h('aenean', 2), h('massa', 2), h('suscipit', 2), h('sollicitudin', 2), h('fusce', 2), h('tempus', 2), h('aliquam,', 2), h('nunc', 2), h('ullamcorper', 2), h('rhoncus', 2), h('metus', 2), h('faucibus,', 2), h('justo', 2), h('magna', 2), h('at', 2), h('tincidunt', 2), h('consectetur', 1), h('tortor,', 1), h('dignissim', 1), h('congue,', 1), h('non,', 1), h('porttitor,', 1), h('nonummy', 1), h('molestie,', 1), h('est', 1), h('eleifend', 1), h('mi,', 1), h('arcu', 1), h('scelerisque', 1), h('vitae,', 1), h('consequat', 1), h('in,', 1), h('pretium', 1), h('volutpat', 1), h('pharetra', 1), h('tempor', 1), h('bibendum', 1), h('odio', 1), h('dui', 1), h('primis', 1), h('faucibus', 1), h('luctus', 1), h('posuere', 1), h('cubilia', 1), h('curae,', 1), h('hendrerit', 1), h('velit', 1), h('mauris,', 1), h('gravida', 1), h('ornare', 1), h('ut,', 1), h('pulvinar', 1), h('varius,', 1), h('turpis', 1), h('nibh,', 1), h('eros', 1), h('id', 1), h('aliquet', 1), h('quis', 1), h('lobortis', 1), h('consectetuer', 1), h('morbi', 1), h('vehicula', 1), h('tortor', 1), h('tellus,', 1), h('id,', 1), h('eu,', 1), h('quam', 1), h('feugiat,', 1), h('posuere,', 1), h('iaculis', 1), h('lectus,', 1), h('tristique', 1), h('mollis,', 1), h('nisl,', 1), h('vulputate', 1), h('sem', 1), h('vivamus', 1), h('placerat', 1), h('imperdiet', 1), h('cursus', 1), h('rutrum', 1), h('iaculis,', 1), h('augue,', 1), h('lacus', 1));
+}
+function lorem(constraints = {}) {
+ const { maxCount, mode = 'words', size } = constraints;
+ if (maxCount !== undefined && maxCount < 1) {
+ throw new Error(`lorem has to produce at least one word/sentence`);
+ }
+ const wordArbitrary = loremWord();
+ if (mode === 'sentences') {
+ const sentence = (0, array_1.array)(wordArbitrary, { minLength: 1, size: 'small' }).map(WordsToLorem_1.wordsToSentenceMapper, (0, WordsToLorem_1.wordsToSentenceUnmapperFor)(wordArbitrary));
+ return (0, array_1.array)(sentence, { minLength: 1, maxLength: maxCount, size }).map(WordsToLorem_1.sentencesToParagraphMapper, WordsToLorem_1.sentencesToParagraphUnmapper);
+ }
+ else {
+ return (0, array_1.array)(wordArbitrary, { minLength: 1, maxLength: maxCount, size }).map(WordsToLorem_1.wordsToJoinedStringMapper, (0, WordsToLorem_1.wordsToJoinedStringUnmapperFor)(wordArbitrary));
+ }
+}
diff --git a/node_modules/fast-check/lib/arbitrary/mapToConstant.js b/node_modules/fast-check/lib/arbitrary/mapToConstant.js
new file mode 100644
index 0000000000000000000000000000000000000000..1efe0589f44589ae8125c07b3f32eae79593f982
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/mapToConstant.js
@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapToConstant = mapToConstant;
+const nat_1 = require("./nat");
+const IndexToMappedConstant_1 = require("./_internals/mappers/IndexToMappedConstant");
+const globals_1 = require("../utils/globals");
+function computeNumChoices(options) {
+ if (options.length === 0)
+ throw new globals_1.Error(`fc.mapToConstant expects at least one option`);
+ let numChoices = 0;
+ for (let idx = 0; idx !== options.length; ++idx) {
+ if (options[idx].num < 0)
+ throw new globals_1.Error(`fc.mapToConstant expects all options to have a number of entries greater or equal to zero`);
+ numChoices += options[idx].num;
+ }
+ if (numChoices === 0)
+ throw new globals_1.Error(`fc.mapToConstant expects at least one choice among options`);
+ return numChoices;
+}
+function mapToConstant(...entries) {
+ const numChoices = computeNumChoices(entries);
+ return (0, nat_1.nat)({ max: numChoices - 1 }).map((0, IndexToMappedConstant_1.indexToMappedConstantMapperFor)(entries), (0, IndexToMappedConstant_1.indexToMappedConstantUnmapperFor)(entries));
+}
diff --git a/node_modules/fast-check/lib/arbitrary/maxSafeInteger.js b/node_modules/fast-check/lib/arbitrary/maxSafeInteger.js
new file mode 100644
index 0000000000000000000000000000000000000000..fef9554f12b742f181ad0f399d5e151ddd5de098
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/maxSafeInteger.js
@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maxSafeInteger = maxSafeInteger;
+const IntegerArbitrary_1 = require("./_internals/IntegerArbitrary");
+const safeMinSafeInteger = Number.MIN_SAFE_INTEGER;
+const safeMaxSafeInteger = Number.MAX_SAFE_INTEGER;
+function maxSafeInteger() {
+ return new IntegerArbitrary_1.IntegerArbitrary(safeMinSafeInteger, safeMaxSafeInteger);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/maxSafeNat.js b/node_modules/fast-check/lib/arbitrary/maxSafeNat.js
new file mode 100644
index 0000000000000000000000000000000000000000..e358970d540c5122277671df470412d1e192ece2
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/maxSafeNat.js
@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maxSafeNat = maxSafeNat;
+const IntegerArbitrary_1 = require("./_internals/IntegerArbitrary");
+const safeMaxSafeInteger = Number.MAX_SAFE_INTEGER;
+function maxSafeNat() {
+ return new IntegerArbitrary_1.IntegerArbitrary(0, safeMaxSafeInteger);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/memo.js b/node_modules/fast-check/lib/arbitrary/memo.js
new file mode 100644
index 0000000000000000000000000000000000000000..0b6513c0a96370153496193340e4ff386a0fcc53
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/memo.js
@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memo = memo;
+const globals_1 = require("../utils/globals");
+let contextRemainingDepth = 10;
+function memo(builder) {
+ const previous = {};
+ return ((maxDepth) => {
+ const n = maxDepth !== undefined ? maxDepth : contextRemainingDepth;
+ if (!(0, globals_1.safeHasOwnProperty)(previous, n)) {
+ const prev = contextRemainingDepth;
+ contextRemainingDepth = n - 1;
+ previous[n] = builder(n);
+ contextRemainingDepth = prev;
+ }
+ return previous[n];
+ });
+}
diff --git a/node_modules/fast-check/lib/arbitrary/mixedCase.js b/node_modules/fast-check/lib/arbitrary/mixedCase.js
new file mode 100644
index 0000000000000000000000000000000000000000..f65662f76732d07c2c39f5c7c45a909e4dcf21d1
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/mixedCase.js
@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mixedCase = mixedCase;
+const globals_1 = require("../utils/globals");
+const MixedCaseArbitrary_1 = require("./_internals/MixedCaseArbitrary");
+function defaultToggleCase(rawChar) {
+ const upper = (0, globals_1.safeToUpperCase)(rawChar);
+ if (upper !== rawChar)
+ return upper;
+ return (0, globals_1.safeToLowerCase)(rawChar);
+}
+function mixedCase(stringArb, constraints) {
+ if (typeof globals_1.BigInt === 'undefined') {
+ throw new globals_1.Error(`mixedCase requires BigInt support`);
+ }
+ const toggleCase = (constraints && constraints.toggleCase) || defaultToggleCase;
+ const untoggleAll = constraints && constraints.untoggleAll;
+ return new MixedCaseArbitrary_1.MixedCaseArbitrary(stringArb, toggleCase, untoggleAll);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/nat.js b/node_modules/fast-check/lib/arbitrary/nat.js
new file mode 100644
index 0000000000000000000000000000000000000000..845402fe7e45543198ca074b99df3553ba0c73c5
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/nat.js
@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nat = nat;
+const IntegerArbitrary_1 = require("./_internals/IntegerArbitrary");
+const safeNumberIsInteger = Number.isInteger;
+function nat(arg) {
+ const max = typeof arg === 'number' ? arg : arg && arg.max !== undefined ? arg.max : 0x7fffffff;
+ if (max < 0) {
+ throw new Error('fc.nat value should be greater than or equal to 0');
+ }
+ if (!safeNumberIsInteger(max)) {
+ throw new Error('fc.nat maximum value should be an integer');
+ }
+ return new IntegerArbitrary_1.IntegerArbitrary(0, max);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/noBias.js b/node_modules/fast-check/lib/arbitrary/noBias.js
new file mode 100644
index 0000000000000000000000000000000000000000..e8f0e60e72ba1c6da1744162014986cde8a7cb17
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/noBias.js
@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noBias = noBias;
+function noBias(arb) {
+ return arb.noBias();
+}
diff --git a/node_modules/fast-check/lib/arbitrary/noShrink.js b/node_modules/fast-check/lib/arbitrary/noShrink.js
new file mode 100644
index 0000000000000000000000000000000000000000..5d85fe28ce0d88d6084ae390b441df9e5320b175
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/noShrink.js
@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noShrink = noShrink;
+function noShrink(arb) {
+ return arb.noShrink();
+}
diff --git a/node_modules/fast-check/lib/arbitrary/object.js b/node_modules/fast-check/lib/arbitrary/object.js
new file mode 100644
index 0000000000000000000000000000000000000000..42638ce31c4171225524d228bbdf28d0714c7483
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/object.js
@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.object = object;
+const dictionary_1 = require("./dictionary");
+const AnyArbitraryBuilder_1 = require("./_internals/builders/AnyArbitraryBuilder");
+const QualifiedObjectConstraints_1 = require("./_internals/helpers/QualifiedObjectConstraints");
+function objectInternal(constraints) {
+ return (0, dictionary_1.dictionary)(constraints.key, (0, AnyArbitraryBuilder_1.anyArbitraryBuilder)(constraints), {
+ maxKeys: constraints.maxKeys,
+ noNullPrototype: !constraints.withNullPrototype,
+ size: constraints.size,
+ });
+}
+function object(constraints) {
+ return objectInternal((0, QualifiedObjectConstraints_1.toQualifiedObjectConstraints)(constraints));
+}
diff --git a/node_modules/fast-check/lib/arbitrary/oneof.js b/node_modules/fast-check/lib/arbitrary/oneof.js
new file mode 100644
index 0000000000000000000000000000000000000000..2284da5ef36ddc476174c8698801cd45263df10d
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/oneof.js
@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.oneof = oneof;
+const Arbitrary_1 = require("../check/arbitrary/definition/Arbitrary");
+const globals_1 = require("../utils/globals");
+const FrequencyArbitrary_1 = require("./_internals/FrequencyArbitrary");
+function isOneOfContraints(param) {
+ return (param != null &&
+ typeof param === 'object' &&
+ !('generate' in param) &&
+ !('arbitrary' in param) &&
+ !('weight' in param));
+}
+function toWeightedArbitrary(maybeWeightedArbitrary) {
+ if ((0, Arbitrary_1.isArbitrary)(maybeWeightedArbitrary)) {
+ return { arbitrary: maybeWeightedArbitrary, weight: 1 };
+ }
+ return maybeWeightedArbitrary;
+}
+function oneof(...args) {
+ const constraints = args[0];
+ if (isOneOfContraints(constraints)) {
+ const weightedArbs = (0, globals_1.safeMap)((0, globals_1.safeSlice)(args, 1), toWeightedArbitrary);
+ return FrequencyArbitrary_1.FrequencyArbitrary.from(weightedArbs, constraints, 'fc.oneof');
+ }
+ const weightedArbs = (0, globals_1.safeMap)(args, toWeightedArbitrary);
+ return FrequencyArbitrary_1.FrequencyArbitrary.from(weightedArbs, {}, 'fc.oneof');
+}
diff --git a/node_modules/fast-check/lib/arbitrary/option.js b/node_modules/fast-check/lib/arbitrary/option.js
new file mode 100644
index 0000000000000000000000000000000000000000..8da68ad89b63399d1cfbabf190b55634a54a16dd
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/option.js
@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.option = option;
+const constant_1 = require("./constant");
+const FrequencyArbitrary_1 = require("./_internals/FrequencyArbitrary");
+const globals_1 = require("../utils/globals");
+function option(arb, constraints = {}) {
+ const freq = constraints.freq == null ? 5 : constraints.freq;
+ const nilValue = (0, globals_1.safeHasOwnProperty)(constraints, 'nil') ? constraints.nil : null;
+ const nilArb = (0, constant_1.constant)(nilValue);
+ const weightedArbs = [
+ { arbitrary: nilArb, weight: 1, fallbackValue: { default: nilValue } },
+ { arbitrary: arb, weight: freq },
+ ];
+ const frequencyConstraints = {
+ withCrossShrink: true,
+ depthSize: constraints.depthSize,
+ maxDepth: constraints.maxDepth,
+ depthIdentifier: constraints.depthIdentifier,
+ };
+ return FrequencyArbitrary_1.FrequencyArbitrary.from(weightedArbs, frequencyConstraints, 'fc.option');
+}
diff --git a/node_modules/fast-check/lib/arbitrary/record.js b/node_modules/fast-check/lib/arbitrary/record.js
new file mode 100644
index 0000000000000000000000000000000000000000..7729ec064d587ee3dd65d51abfa334bf1c6741e6
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/record.js
@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.record = record;
+const PartialRecordArbitraryBuilder_1 = require("./_internals/builders/PartialRecordArbitraryBuilder");
+function record(recordModel, constraints) {
+ const noNullPrototype = constraints === undefined || constraints.noNullPrototype === undefined || constraints.noNullPrototype;
+ if (constraints == null) {
+ return (0, PartialRecordArbitraryBuilder_1.buildPartialRecordArbitrary)(recordModel, undefined, noNullPrototype);
+ }
+ if ('withDeletedKeys' in constraints && 'requiredKeys' in constraints) {
+ throw new Error(`requiredKeys and withDeletedKeys cannot be used together in fc.record`);
+ }
+ const requireDeletedKeys = ('requiredKeys' in constraints && constraints.requiredKeys !== undefined) ||
+ ('withDeletedKeys' in constraints && !!constraints.withDeletedKeys);
+ if (!requireDeletedKeys) {
+ return (0, PartialRecordArbitraryBuilder_1.buildPartialRecordArbitrary)(recordModel, undefined, noNullPrototype);
+ }
+ const requiredKeys = ('requiredKeys' in constraints ? constraints.requiredKeys : undefined) || [];
+ for (let idx = 0; idx !== requiredKeys.length; ++idx) {
+ const descriptor = Object.getOwnPropertyDescriptor(recordModel, requiredKeys[idx]);
+ if (descriptor === undefined) {
+ throw new Error(`requiredKeys cannot reference keys that have not been defined in recordModel`);
+ }
+ if (!descriptor.enumerable) {
+ throw new Error(`requiredKeys cannot reference keys that have are enumerable in recordModel`);
+ }
+ }
+ return (0, PartialRecordArbitraryBuilder_1.buildPartialRecordArbitrary)(recordModel, requiredKeys, noNullPrototype);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/scheduler.js b/node_modules/fast-check/lib/arbitrary/scheduler.js
new file mode 100644
index 0000000000000000000000000000000000000000..fb211cb5d5a23475d9e23f020843df240a566519
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/scheduler.js
@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scheduler = scheduler;
+exports.schedulerFor = schedulerFor;
+const BuildSchedulerFor_1 = require("./_internals/helpers/BuildSchedulerFor");
+const SchedulerArbitrary_1 = require("./_internals/SchedulerArbitrary");
+function scheduler(constraints) {
+ const { act = (f) => f() } = constraints || {};
+ return new SchedulerArbitrary_1.SchedulerArbitrary(act);
+}
+function schedulerFor(customOrderingOrConstraints, constraintsOrUndefined) {
+ const { act = (f) => f() } = Array.isArray(customOrderingOrConstraints)
+ ? constraintsOrUndefined || {}
+ : customOrderingOrConstraints || {};
+ if (Array.isArray(customOrderingOrConstraints)) {
+ return (0, BuildSchedulerFor_1.buildSchedulerFor)(act, customOrderingOrConstraints);
+ }
+ return function (_strs, ...ordering) {
+ return (0, BuildSchedulerFor_1.buildSchedulerFor)(act, ordering);
+ };
+}
diff --git a/node_modules/fast-check/lib/arbitrary/shuffledSubarray.js b/node_modules/fast-check/lib/arbitrary/shuffledSubarray.js
new file mode 100644
index 0000000000000000000000000000000000000000..2a4ed1341b595d6d43c01f5347b819d84467131e
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/shuffledSubarray.js
@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shuffledSubarray = shuffledSubarray;
+const SubarrayArbitrary_1 = require("./_internals/SubarrayArbitrary");
+function shuffledSubarray(originalArray, constraints = {}) {
+ const { minLength = 0, maxLength = originalArray.length } = constraints;
+ return new SubarrayArbitrary_1.SubarrayArbitrary(originalArray, false, minLength, maxLength);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/sparseArray.js b/node_modules/fast-check/lib/arbitrary/sparseArray.js
new file mode 100644
index 0000000000000000000000000000000000000000..d0902d7d7cc4261e0e8cef21b7eec2980784c5a0
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/sparseArray.js
@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sparseArray = sparseArray;
+const globals_1 = require("../utils/globals");
+const tuple_1 = require("./tuple");
+const uniqueArray_1 = require("./uniqueArray");
+const RestrictedIntegerArbitraryBuilder_1 = require("./_internals/builders/RestrictedIntegerArbitraryBuilder");
+const MaxLengthFromMinLength_1 = require("./_internals/helpers/MaxLengthFromMinLength");
+const safeMathMin = Math.min;
+const safeMathMax = Math.max;
+const safeArrayIsArray = globals_1.Array.isArray;
+const safeObjectEntries = Object.entries;
+function extractMaxIndex(indexesAndValues) {
+ let maxIndex = -1;
+ for (let index = 0; index !== indexesAndValues.length; ++index) {
+ maxIndex = safeMathMax(maxIndex, indexesAndValues[index][0]);
+ }
+ return maxIndex;
+}
+function arrayFromItems(length, indexesAndValues) {
+ const array = (0, globals_1.Array)(length);
+ for (let index = 0; index !== indexesAndValues.length; ++index) {
+ const it = indexesAndValues[index];
+ if (it[0] < length)
+ array[it[0]] = it[1];
+ }
+ return array;
+}
+function sparseArray(arb, constraints = {}) {
+ const { size, minNumElements = 0, maxLength = MaxLengthFromMinLength_1.MaxLengthUpperBound, maxNumElements = maxLength, noTrailingHole, depthIdentifier, } = constraints;
+ const maxGeneratedNumElements = (0, MaxLengthFromMinLength_1.maxGeneratedLengthFromSizeForArbitrary)(size, minNumElements, maxNumElements, constraints.maxNumElements !== undefined);
+ const maxGeneratedLength = (0, MaxLengthFromMinLength_1.maxGeneratedLengthFromSizeForArbitrary)(size, maxGeneratedNumElements, maxLength, constraints.maxLength !== undefined);
+ if (minNumElements > maxLength) {
+ throw new Error(`The minimal number of non-hole elements cannot be higher than the maximal length of the array`);
+ }
+ if (minNumElements > maxNumElements) {
+ throw new Error(`The minimal number of non-hole elements cannot be higher than the maximal number of non-holes`);
+ }
+ const resultedMaxNumElements = safeMathMin(maxNumElements, maxLength);
+ const resultedSizeMaxNumElements = constraints.maxNumElements !== undefined || size !== undefined ? size : '=';
+ const maxGeneratedIndexAuthorized = safeMathMax(maxGeneratedLength - 1, 0);
+ const maxIndexAuthorized = safeMathMax(maxLength - 1, 0);
+ const sparseArrayNoTrailingHole = (0, uniqueArray_1.uniqueArray)((0, tuple_1.tuple)((0, RestrictedIntegerArbitraryBuilder_1.restrictedIntegerArbitraryBuilder)(0, maxGeneratedIndexAuthorized, maxIndexAuthorized), arb), {
+ size: resultedSizeMaxNumElements,
+ minLength: minNumElements,
+ maxLength: resultedMaxNumElements,
+ selector: (item) => item[0],
+ depthIdentifier,
+ }).map((items) => {
+ const lastIndex = extractMaxIndex(items);
+ return arrayFromItems(lastIndex + 1, items);
+ }, (value) => {
+ if (!safeArrayIsArray(value)) {
+ throw new Error('Not supported entry type');
+ }
+ if (noTrailingHole && value.length !== 0 && !(value.length - 1 in value)) {
+ throw new Error('No trailing hole');
+ }
+ return (0, globals_1.safeMap)(safeObjectEntries(value), (entry) => [Number(entry[0]), entry[1]]);
+ });
+ if (noTrailingHole || maxLength === minNumElements) {
+ return sparseArrayNoTrailingHole;
+ }
+ return (0, tuple_1.tuple)(sparseArrayNoTrailingHole, (0, RestrictedIntegerArbitraryBuilder_1.restrictedIntegerArbitraryBuilder)(minNumElements, maxGeneratedLength, maxLength)).map((data) => {
+ const sparse = data[0];
+ const targetLength = data[1];
+ if (sparse.length >= targetLength) {
+ return sparse;
+ }
+ const longerSparse = (0, globals_1.safeSlice)(sparse);
+ longerSparse.length = targetLength;
+ return longerSparse;
+ }, (value) => {
+ if (!safeArrayIsArray(value)) {
+ throw new Error('Not supported entry type');
+ }
+ return [value, value.length];
+ });
+}
diff --git a/node_modules/fast-check/lib/arbitrary/string.js b/node_modules/fast-check/lib/arbitrary/string.js
new file mode 100644
index 0000000000000000000000000000000000000000..c4efbd06ba04d9dbd8f259e40d3d14a7326b11a5
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/string.js
@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.string = string;
+const array_1 = require("./array");
+const SlicesForStringBuilder_1 = require("./_internals/helpers/SlicesForStringBuilder");
+const StringUnitArbitrary_1 = require("./_internals/StringUnitArbitrary");
+const PatternsToString_1 = require("./_internals/mappers/PatternsToString");
+const safeObjectAssign = Object.assign;
+function extractUnitArbitrary(constraints) {
+ if (typeof constraints.unit === 'object') {
+ return constraints.unit;
+ }
+ switch (constraints.unit) {
+ case 'grapheme':
+ return (0, StringUnitArbitrary_1.stringUnit)('grapheme', 'full');
+ case 'grapheme-composite':
+ return (0, StringUnitArbitrary_1.stringUnit)('composite', 'full');
+ case 'grapheme-ascii':
+ case undefined:
+ return (0, StringUnitArbitrary_1.stringUnit)('grapheme', 'ascii');
+ case 'binary':
+ return (0, StringUnitArbitrary_1.stringUnit)('binary', 'full');
+ case 'binary-ascii':
+ return (0, StringUnitArbitrary_1.stringUnit)('binary', 'ascii');
+ }
+}
+function string(constraints = {}) {
+ const charArbitrary = extractUnitArbitrary(constraints);
+ const unmapper = (0, PatternsToString_1.patternsToStringUnmapperFor)(charArbitrary, constraints);
+ const experimentalCustomSlices = (0, SlicesForStringBuilder_1.createSlicesForString)(charArbitrary, constraints);
+ const enrichedConstraints = safeObjectAssign(safeObjectAssign({}, constraints), {
+ experimentalCustomSlices,
+ });
+ return (0, array_1.array)(charArbitrary, enrichedConstraints).map(PatternsToString_1.patternsToStringMapper, unmapper);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/string16bits.js b/node_modules/fast-check/lib/arbitrary/string16bits.js
new file mode 100644
index 0000000000000000000000000000000000000000..2612dd6ae8c6840a8b3e513bd23b477022f9f019
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/string16bits.js
@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.string16bits = string16bits;
+const array_1 = require("./array");
+const char16bits_1 = require("./char16bits");
+const CharsToString_1 = require("./_internals/mappers/CharsToString");
+const SlicesForStringBuilder_1 = require("./_internals/helpers/SlicesForStringBuilder");
+const safeObjectAssign = Object.assign;
+function string16bits(constraints = {}) {
+ const charArbitrary = (0, char16bits_1.char16bits)();
+ const experimentalCustomSlices = (0, SlicesForStringBuilder_1.createSlicesForStringLegacy)(charArbitrary, CharsToString_1.charsToStringUnmapper);
+ const enrichedConstraints = safeObjectAssign(safeObjectAssign({}, constraints), {
+ experimentalCustomSlices,
+ });
+ return (0, array_1.array)(charArbitrary, enrichedConstraints).map(CharsToString_1.charsToStringMapper, CharsToString_1.charsToStringUnmapper);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/stringMatching.js b/node_modules/fast-check/lib/arbitrary/stringMatching.js
new file mode 100644
index 0000000000000000000000000000000000000000..eb2c1bf2ed1dcff28967512aa2e1d74b1967c67c
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/stringMatching.js
@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringMatching = stringMatching;
+const globals_1 = require("../utils/globals");
+const stringify_1 = require("../utils/stringify");
+const SanitizeRegexAst_1 = require("./_internals/helpers/SanitizeRegexAst");
+const TokenizeRegex_1 = require("./_internals/helpers/TokenizeRegex");
+const char_1 = require("./char");
+const constant_1 = require("./constant");
+const constantFrom_1 = require("./constantFrom");
+const integer_1 = require("./integer");
+const oneof_1 = require("./oneof");
+const stringOf_1 = require("./stringOf");
+const tuple_1 = require("./tuple");
+const safeStringFromCodePoint = String.fromCodePoint;
+const wordChars = [...'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_'];
+const digitChars = [...'0123456789'];
+const spaceChars = [...' \t\r\n\v\f'];
+const newLineChars = [...'\r\n'];
+const terminatorChars = [...'\x1E\x15'];
+const newLineAndTerminatorChars = [...newLineChars, ...terminatorChars];
+const defaultChar = (0, char_1.char)();
+function raiseUnsupportedASTNode(astNode) {
+ return new globals_1.Error(`Unsupported AST node! Received: ${(0, stringify_1.stringify)(astNode)}`);
+}
+function toMatchingArbitrary(astNode, constraints, flags) {
+ switch (astNode.type) {
+ case 'Char': {
+ if (astNode.kind === 'meta') {
+ switch (astNode.value) {
+ case '\\w': {
+ return (0, constantFrom_1.constantFrom)(...wordChars);
+ }
+ case '\\W': {
+ return defaultChar.filter((c) => (0, globals_1.safeIndexOf)(wordChars, c) === -1);
+ }
+ case '\\d': {
+ return (0, constantFrom_1.constantFrom)(...digitChars);
+ }
+ case '\\D': {
+ return defaultChar.filter((c) => (0, globals_1.safeIndexOf)(digitChars, c) === -1);
+ }
+ case '\\s': {
+ return (0, constantFrom_1.constantFrom)(...spaceChars);
+ }
+ case '\\S': {
+ return defaultChar.filter((c) => (0, globals_1.safeIndexOf)(spaceChars, c) === -1);
+ }
+ case '\\b':
+ case '\\B': {
+ throw new globals_1.Error(`Meta character ${astNode.value} not implemented yet!`);
+ }
+ case '.': {
+ const forbiddenChars = flags.dotAll ? terminatorChars : newLineAndTerminatorChars;
+ return defaultChar.filter((c) => (0, globals_1.safeIndexOf)(forbiddenChars, c) === -1);
+ }
+ }
+ }
+ if (astNode.symbol === undefined) {
+ throw new globals_1.Error(`Unexpected undefined symbol received for non-meta Char! Received: ${(0, stringify_1.stringify)(astNode)}`);
+ }
+ return (0, constant_1.constant)(astNode.symbol);
+ }
+ case 'Repetition': {
+ const node = toMatchingArbitrary(astNode.expression, constraints, flags);
+ switch (astNode.quantifier.kind) {
+ case '*': {
+ return (0, stringOf_1.stringOf)(node, constraints);
+ }
+ case '+': {
+ return (0, stringOf_1.stringOf)(node, Object.assign(Object.assign({}, constraints), { minLength: 1 }));
+ }
+ case '?': {
+ return (0, stringOf_1.stringOf)(node, Object.assign(Object.assign({}, constraints), { minLength: 0, maxLength: 1 }));
+ }
+ case 'Range': {
+ return (0, stringOf_1.stringOf)(node, Object.assign(Object.assign({}, constraints), { minLength: astNode.quantifier.from, maxLength: astNode.quantifier.to }));
+ }
+ default: {
+ throw raiseUnsupportedASTNode(astNode.quantifier);
+ }
+ }
+ }
+ case 'Quantifier': {
+ throw new globals_1.Error(`Wrongly defined AST tree, Quantifier nodes not supposed to be scanned!`);
+ }
+ case 'Alternative': {
+ return (0, tuple_1.tuple)(...(0, globals_1.safeMap)(astNode.expressions, (n) => toMatchingArbitrary(n, constraints, flags))).map((vs) => (0, globals_1.safeJoin)(vs, ''));
+ }
+ case 'CharacterClass':
+ if (astNode.negative) {
+ const childrenArbitraries = (0, globals_1.safeMap)(astNode.expressions, (n) => toMatchingArbitrary(n, constraints, flags));
+ return defaultChar.filter((c) => (0, globals_1.safeEvery)(childrenArbitraries, (arb) => !arb.canShrinkWithoutContext(c)));
+ }
+ return (0, oneof_1.oneof)(...(0, globals_1.safeMap)(astNode.expressions, (n) => toMatchingArbitrary(n, constraints, flags)));
+ case 'ClassRange': {
+ const min = astNode.from.codePoint;
+ const max = astNode.to.codePoint;
+ return (0, integer_1.integer)({ min, max }).map((n) => safeStringFromCodePoint(n), (c) => {
+ if (typeof c !== 'string')
+ throw new globals_1.Error('Invalid type');
+ if ([...c].length !== 1)
+ throw new globals_1.Error('Invalid length');
+ return (0, globals_1.safeCharCodeAt)(c, 0);
+ });
+ }
+ case 'Group': {
+ return toMatchingArbitrary(astNode.expression, constraints, flags);
+ }
+ case 'Disjunction': {
+ const left = astNode.left !== null ? toMatchingArbitrary(astNode.left, constraints, flags) : (0, constant_1.constant)('');
+ const right = astNode.right !== null ? toMatchingArbitrary(astNode.right, constraints, flags) : (0, constant_1.constant)('');
+ return (0, oneof_1.oneof)(left, right);
+ }
+ case 'Assertion': {
+ if (astNode.kind === '^' || astNode.kind === '$') {
+ if (flags.multiline) {
+ if (astNode.kind === '^') {
+ return (0, oneof_1.oneof)((0, constant_1.constant)(''), (0, tuple_1.tuple)((0, stringOf_1.stringOf)(defaultChar), (0, constantFrom_1.constantFrom)(...newLineChars)).map((t) => `${t[0]}${t[1]}`, (value) => {
+ if (typeof value !== 'string' || value.length === 0)
+ throw new globals_1.Error('Invalid type');
+ return [(0, globals_1.safeSubstring)(value, 0, value.length - 1), value[value.length - 1]];
+ }));
+ }
+ else {
+ return (0, oneof_1.oneof)((0, constant_1.constant)(''), (0, tuple_1.tuple)((0, constantFrom_1.constantFrom)(...newLineChars), (0, stringOf_1.stringOf)(defaultChar)).map((t) => `${t[0]}${t[1]}`, (value) => {
+ if (typeof value !== 'string' || value.length === 0)
+ throw new globals_1.Error('Invalid type');
+ return [value[0], (0, globals_1.safeSubstring)(value, 1)];
+ }));
+ }
+ }
+ return (0, constant_1.constant)('');
+ }
+ throw new globals_1.Error(`Assertions of kind ${astNode.kind} not implemented yet!`);
+ }
+ case 'Backreference': {
+ throw new globals_1.Error(`Backreference nodes not implemented yet!`);
+ }
+ default: {
+ throw raiseUnsupportedASTNode(astNode);
+ }
+ }
+}
+function stringMatching(regex, constraints = {}) {
+ for (const flag of regex.flags) {
+ if (flag !== 'd' && flag !== 'g' && flag !== 'm' && flag !== 's' && flag !== 'u') {
+ throw new globals_1.Error(`Unable to use "stringMatching" against a regex using the flag ${flag}`);
+ }
+ }
+ const sanitizedConstraints = { size: constraints.size };
+ const flags = { multiline: regex.multiline, dotAll: regex.dotAll };
+ const regexRootToken = (0, SanitizeRegexAst_1.addMissingDotStar)((0, TokenizeRegex_1.tokenizeRegex)(regex));
+ return toMatchingArbitrary(regexRootToken, sanitizedConstraints, flags);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/stringOf.js b/node_modules/fast-check/lib/arbitrary/stringOf.js
new file mode 100644
index 0000000000000000000000000000000000000000..f3812167368e384bb950965d6d1c2bfc405b8651
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/stringOf.js
@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringOf = stringOf;
+const array_1 = require("./array");
+const PatternsToString_1 = require("./_internals/mappers/PatternsToString");
+const SlicesForStringBuilder_1 = require("./_internals/helpers/SlicesForStringBuilder");
+const safeObjectAssign = Object.assign;
+function stringOf(charArb, constraints = {}) {
+ const unmapper = (0, PatternsToString_1.patternsToStringUnmapperFor)(charArb, constraints);
+ const experimentalCustomSlices = (0, SlicesForStringBuilder_1.createSlicesForStringLegacy)(charArb, unmapper);
+ const enrichedConstraints = safeObjectAssign(safeObjectAssign({}, constraints), {
+ experimentalCustomSlices,
+ });
+ return (0, array_1.array)(charArb, enrichedConstraints).map(PatternsToString_1.patternsToStringMapper, unmapper);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/subarray.js b/node_modules/fast-check/lib/arbitrary/subarray.js
new file mode 100644
index 0000000000000000000000000000000000000000..901f91da9d6e33549e048d5ae182a39b07f970b3
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/subarray.js
@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subarray = subarray;
+const SubarrayArbitrary_1 = require("./_internals/SubarrayArbitrary");
+function subarray(originalArray, constraints = {}) {
+ const { minLength = 0, maxLength = originalArray.length } = constraints;
+ return new SubarrayArbitrary_1.SubarrayArbitrary(originalArray, true, minLength, maxLength);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/tuple.js b/node_modules/fast-check/lib/arbitrary/tuple.js
new file mode 100644
index 0000000000000000000000000000000000000000..e7494b368e5d4051eb65518178e5f264ae402e9d
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/tuple.js
@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tuple = tuple;
+const TupleArbitrary_1 = require("./_internals/TupleArbitrary");
+function tuple(...arbs) {
+ return new TupleArbitrary_1.TupleArbitrary(arbs);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/uint16Array.js b/node_modules/fast-check/lib/arbitrary/uint16Array.js
new file mode 100644
index 0000000000000000000000000000000000000000..0cef97f0573a022526dd06b50814a07edc1ba50f
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/uint16Array.js
@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uint16Array = uint16Array;
+const globals_1 = require("../utils/globals");
+const integer_1 = require("./integer");
+const TypedIntArrayArbitraryBuilder_1 = require("./_internals/builders/TypedIntArrayArbitraryBuilder");
+function uint16Array(constraints = {}) {
+ return (0, TypedIntArrayArbitraryBuilder_1.typedIntArrayArbitraryArbitraryBuilder)(constraints, 0, 65535, globals_1.Uint16Array, integer_1.integer);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/uint32Array.js b/node_modules/fast-check/lib/arbitrary/uint32Array.js
new file mode 100644
index 0000000000000000000000000000000000000000..d3f7487cffd98fcb2b5132be0771d8b23901642a
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/uint32Array.js
@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uint32Array = uint32Array;
+const globals_1 = require("../utils/globals");
+const integer_1 = require("./integer");
+const TypedIntArrayArbitraryBuilder_1 = require("./_internals/builders/TypedIntArrayArbitraryBuilder");
+function uint32Array(constraints = {}) {
+ return (0, TypedIntArrayArbitraryBuilder_1.typedIntArrayArbitraryArbitraryBuilder)(constraints, 0, 0xffffffff, globals_1.Uint32Array, integer_1.integer);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/uint8Array.js b/node_modules/fast-check/lib/arbitrary/uint8Array.js
new file mode 100644
index 0000000000000000000000000000000000000000..3ecf0dd520fd6a31d519e86cf9cd25108004b27d
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/uint8Array.js
@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uint8Array = uint8Array;
+const globals_1 = require("../utils/globals");
+const integer_1 = require("./integer");
+const TypedIntArrayArbitraryBuilder_1 = require("./_internals/builders/TypedIntArrayArbitraryBuilder");
+function uint8Array(constraints = {}) {
+ return (0, TypedIntArrayArbitraryBuilder_1.typedIntArrayArbitraryArbitraryBuilder)(constraints, 0, 255, globals_1.Uint8Array, integer_1.integer);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/uint8ClampedArray.js b/node_modules/fast-check/lib/arbitrary/uint8ClampedArray.js
new file mode 100644
index 0000000000000000000000000000000000000000..bde163de4e57cf0b5d2a785f45e355eca9c1b2c4
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/uint8ClampedArray.js
@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uint8ClampedArray = uint8ClampedArray;
+const globals_1 = require("../utils/globals");
+const integer_1 = require("./integer");
+const TypedIntArrayArbitraryBuilder_1 = require("./_internals/builders/TypedIntArrayArbitraryBuilder");
+function uint8ClampedArray(constraints = {}) {
+ return (0, TypedIntArrayArbitraryBuilder_1.typedIntArrayArbitraryArbitraryBuilder)(constraints, 0, 255, globals_1.Uint8ClampedArray, integer_1.integer);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/ulid.js b/node_modules/fast-check/lib/arbitrary/ulid.js
new file mode 100644
index 0000000000000000000000000000000000000000..c96c2127451aa12f951ef47ce00e13845f14ef59
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/ulid.js
@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ulid = ulid;
+const tuple_1 = require("./tuple");
+const integer_1 = require("./integer");
+const UintToBase32String_1 = require("./_internals/mappers/UintToBase32String");
+const padded10Mapper = (0, UintToBase32String_1.paddedUintToBase32StringMapper)(10);
+const padded8Mapper = (0, UintToBase32String_1.paddedUintToBase32StringMapper)(8);
+function ulidMapper(parts) {
+ return (padded10Mapper(parts[0]) +
+ padded8Mapper(parts[1]) +
+ padded8Mapper(parts[2]));
+}
+function ulidUnmapper(value) {
+ if (typeof value !== 'string' || value.length !== 26) {
+ throw new Error('Unsupported type');
+ }
+ return [
+ (0, UintToBase32String_1.uintToBase32StringUnmapper)(value.slice(0, 10)),
+ (0, UintToBase32String_1.uintToBase32StringUnmapper)(value.slice(10, 18)),
+ (0, UintToBase32String_1.uintToBase32StringUnmapper)(value.slice(18)),
+ ];
+}
+function ulid() {
+ const timestampPartArbitrary = (0, integer_1.integer)({ min: 0, max: 0xffffffffffff });
+ const randomnessPartOneArbitrary = (0, integer_1.integer)({ min: 0, max: 0xffffffffff });
+ const randomnessPartTwoArbitrary = (0, integer_1.integer)({ min: 0, max: 0xffffffffff });
+ return (0, tuple_1.tuple)(timestampPartArbitrary, randomnessPartOneArbitrary, randomnessPartTwoArbitrary).map(ulidMapper, ulidUnmapper);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/unicode.js b/node_modules/fast-check/lib/arbitrary/unicode.js
new file mode 100644
index 0000000000000000000000000000000000000000..57116cc7b771f1045dc4f4bf167876a15a2432fa
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/unicode.js
@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unicode = unicode;
+const CharacterArbitraryBuilder_1 = require("./_internals/builders/CharacterArbitraryBuilder");
+const IndexToPrintableIndex_1 = require("./_internals/mappers/IndexToPrintableIndex");
+const gapSize = 0xdfff + 1 - 0xd800;
+function unicodeMapper(v) {
+ if (v < 0xd800)
+ return (0, IndexToPrintableIndex_1.indexToPrintableIndexMapper)(v);
+ return v + gapSize;
+}
+function unicodeUnmapper(v) {
+ if (v < 0xd800)
+ return (0, IndexToPrintableIndex_1.indexToPrintableIndexUnmapper)(v);
+ if (v <= 0xdfff)
+ return -1;
+ return v - gapSize;
+}
+function unicode() {
+ return (0, CharacterArbitraryBuilder_1.buildCharacterArbitrary)(0x0000, 0xffff - gapSize, unicodeMapper, unicodeUnmapper);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/unicodeJson.js b/node_modules/fast-check/lib/arbitrary/unicodeJson.js
new file mode 100644
index 0000000000000000000000000000000000000000..65767a598f3bcddaa3d830ab867e5e8bb5873c4d
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/unicodeJson.js
@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unicodeJson = unicodeJson;
+const unicodeJsonValue_1 = require("./unicodeJsonValue");
+function unicodeJson(constraints = {}) {
+ const arb = (0, unicodeJsonValue_1.unicodeJsonValue)(constraints);
+ return arb.map(JSON.stringify);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/unicodeJsonValue.js b/node_modules/fast-check/lib/arbitrary/unicodeJsonValue.js
new file mode 100644
index 0000000000000000000000000000000000000000..9b1a73cccae2c31b3af148c3f484eb4c6e0495f2
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/unicodeJsonValue.js
@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unicodeJsonValue = unicodeJsonValue;
+const unicodeString_1 = require("./unicodeString");
+const JsonConstraintsBuilder_1 = require("./_internals/helpers/JsonConstraintsBuilder");
+const anything_1 = require("./anything");
+function unicodeJsonValue(constraints = {}) {
+ return (0, anything_1.anything)((0, JsonConstraintsBuilder_1.jsonConstraintsBuilder)((0, unicodeString_1.unicodeString)(), constraints));
+}
diff --git a/node_modules/fast-check/lib/arbitrary/unicodeString.js b/node_modules/fast-check/lib/arbitrary/unicodeString.js
new file mode 100644
index 0000000000000000000000000000000000000000..3314b82df98d0fd40e343e41d7744a2d21190f39
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/unicodeString.js
@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unicodeString = unicodeString;
+const array_1 = require("./array");
+const unicode_1 = require("./unicode");
+const CodePointsToString_1 = require("./_internals/mappers/CodePointsToString");
+const SlicesForStringBuilder_1 = require("./_internals/helpers/SlicesForStringBuilder");
+const safeObjectAssign = Object.assign;
+function unicodeString(constraints = {}) {
+ const charArbitrary = (0, unicode_1.unicode)();
+ const experimentalCustomSlices = (0, SlicesForStringBuilder_1.createSlicesForStringLegacy)(charArbitrary, CodePointsToString_1.codePointsToStringUnmapper);
+ const enrichedConstraints = safeObjectAssign(safeObjectAssign({}, constraints), {
+ experimentalCustomSlices,
+ });
+ return (0, array_1.array)(charArbitrary, enrichedConstraints).map(CodePointsToString_1.codePointsToStringMapper, CodePointsToString_1.codePointsToStringUnmapper);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/uniqueArray.js b/node_modules/fast-check/lib/arbitrary/uniqueArray.js
new file mode 100644
index 0000000000000000000000000000000000000000..da2134c1c7a82c4a6e32c2269a30e16b514f0f39
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/uniqueArray.js
@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uniqueArray = uniqueArray;
+const ArrayArbitrary_1 = require("./_internals/ArrayArbitrary");
+const MaxLengthFromMinLength_1 = require("./_internals/helpers/MaxLengthFromMinLength");
+const CustomEqualSet_1 = require("./_internals/helpers/CustomEqualSet");
+const StrictlyEqualSet_1 = require("./_internals/helpers/StrictlyEqualSet");
+const SameValueSet_1 = require("./_internals/helpers/SameValueSet");
+const SameValueZeroSet_1 = require("./_internals/helpers/SameValueZeroSet");
+function buildUniqueArraySetBuilder(constraints) {
+ if (typeof constraints.comparator === 'function') {
+ if (constraints.selector === undefined) {
+ const comparator = constraints.comparator;
+ const isEqualForBuilder = (nextA, nextB) => comparator(nextA.value_, nextB.value_);
+ return () => new CustomEqualSet_1.CustomEqualSet(isEqualForBuilder);
+ }
+ const comparator = constraints.comparator;
+ const selector = constraints.selector;
+ const refinedSelector = (next) => selector(next.value_);
+ const isEqualForBuilder = (nextA, nextB) => comparator(refinedSelector(nextA), refinedSelector(nextB));
+ return () => new CustomEqualSet_1.CustomEqualSet(isEqualForBuilder);
+ }
+ const selector = constraints.selector || ((v) => v);
+ const refinedSelector = (next) => selector(next.value_);
+ switch (constraints.comparator) {
+ case 'IsStrictlyEqual':
+ return () => new StrictlyEqualSet_1.StrictlyEqualSet(refinedSelector);
+ case 'SameValueZero':
+ return () => new SameValueZeroSet_1.SameValueZeroSet(refinedSelector);
+ case 'SameValue':
+ case undefined:
+ return () => new SameValueSet_1.SameValueSet(refinedSelector);
+ }
+}
+function uniqueArray(arb, constraints = {}) {
+ const minLength = constraints.minLength !== undefined ? constraints.minLength : 0;
+ const maxLength = constraints.maxLength !== undefined ? constraints.maxLength : MaxLengthFromMinLength_1.MaxLengthUpperBound;
+ const maxGeneratedLength = (0, MaxLengthFromMinLength_1.maxGeneratedLengthFromSizeForArbitrary)(constraints.size, minLength, maxLength, constraints.maxLength !== undefined);
+ const depthIdentifier = constraints.depthIdentifier;
+ const setBuilder = buildUniqueArraySetBuilder(constraints);
+ const arrayArb = new ArrayArbitrary_1.ArrayArbitrary(arb, minLength, maxGeneratedLength, maxLength, depthIdentifier, setBuilder, []);
+ if (minLength === 0)
+ return arrayArb;
+ return arrayArb.filter((tab) => tab.length >= minLength);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/uuid.js b/node_modules/fast-check/lib/arbitrary/uuid.js
new file mode 100644
index 0000000000000000000000000000000000000000..c754c6139bba6e146b8e4bc2ea194e43751114f9
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/uuid.js
@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uuid = uuid;
+const tuple_1 = require("./tuple");
+const PaddedNumberArbitraryBuilder_1 = require("./_internals/builders/PaddedNumberArbitraryBuilder");
+const PaddedEightsToUuid_1 = require("./_internals/mappers/PaddedEightsToUuid");
+const globals_1 = require("../utils/globals");
+const VersionsApplierForUuid_1 = require("./_internals/mappers/VersionsApplierForUuid");
+function assertValidVersions(versions) {
+ const found = {};
+ for (const version of versions) {
+ if (found[version]) {
+ throw new globals_1.Error(`Version ${version} has been requested at least twice for uuid`);
+ }
+ found[version] = true;
+ if (version < 1 || version > 15) {
+ throw new globals_1.Error(`Version must be a value in [1-15] for uuid, but received ${version}`);
+ }
+ if (~~version !== version) {
+ throw new globals_1.Error(`Version must be an integer value for uuid, but received ${version}`);
+ }
+ }
+ if (versions.length === 0) {
+ throw new globals_1.Error(`Must provide at least one version for uuid`);
+ }
+}
+function uuid(constraints = {}) {
+ const padded = (0, PaddedNumberArbitraryBuilder_1.buildPaddedNumberArbitrary)(0, 0xffffffff);
+ const version = constraints.version !== undefined
+ ? typeof constraints.version === 'number'
+ ? [constraints.version]
+ : constraints.version
+ : [1, 2, 3, 4, 5];
+ assertValidVersions(version);
+ const { versionsApplierMapper, versionsApplierUnmapper } = (0, VersionsApplierForUuid_1.buildVersionsAppliersForUuid)(version);
+ const secondPadded = (0, PaddedNumberArbitraryBuilder_1.buildPaddedNumberArbitrary)(0, 0x10000000 * version.length - 1).map(versionsApplierMapper, versionsApplierUnmapper);
+ const thirdPadded = (0, PaddedNumberArbitraryBuilder_1.buildPaddedNumberArbitrary)(0x80000000, 0xbfffffff);
+ return (0, tuple_1.tuple)(padded, secondPadded, thirdPadded, padded).map(PaddedEightsToUuid_1.paddedEightsToUuidMapper, PaddedEightsToUuid_1.paddedEightsToUuidUnmapper);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/uuidV.js b/node_modules/fast-check/lib/arbitrary/uuidV.js
new file mode 100644
index 0000000000000000000000000000000000000000..fb1d7c5469ee80ec9cb0a49fdfca9ba0f79a1e8d
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/uuidV.js
@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uuidV = uuidV;
+const tuple_1 = require("./tuple");
+const PaddedNumberArbitraryBuilder_1 = require("./_internals/builders/PaddedNumberArbitraryBuilder");
+const PaddedEightsToUuid_1 = require("./_internals/mappers/PaddedEightsToUuid");
+function uuidV(versionNumber) {
+ const padded = (0, PaddedNumberArbitraryBuilder_1.buildPaddedNumberArbitrary)(0, 0xffffffff);
+ const offsetSecond = versionNumber * 0x10000000;
+ const secondPadded = (0, PaddedNumberArbitraryBuilder_1.buildPaddedNumberArbitrary)(offsetSecond, offsetSecond + 0x0fffffff);
+ const thirdPadded = (0, PaddedNumberArbitraryBuilder_1.buildPaddedNumberArbitrary)(0x80000000, 0xbfffffff);
+ return (0, tuple_1.tuple)(padded, secondPadded, thirdPadded, padded).map(PaddedEightsToUuid_1.paddedEightsToUuidMapper, PaddedEightsToUuid_1.paddedEightsToUuidUnmapper);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/webAuthority.js b/node_modules/fast-check/lib/arbitrary/webAuthority.js
new file mode 100644
index 0000000000000000000000000000000000000000..0908a5e29299f448e97a0adc32f0ba99a938739b
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/webAuthority.js
@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webAuthority = webAuthority;
+const CharacterRangeArbitraryBuilder_1 = require("./_internals/builders/CharacterRangeArbitraryBuilder");
+const constant_1 = require("./constant");
+const domain_1 = require("./domain");
+const ipV4_1 = require("./ipV4");
+const ipV4Extended_1 = require("./ipV4Extended");
+const ipV6_1 = require("./ipV6");
+const nat_1 = require("./nat");
+const oneof_1 = require("./oneof");
+const option_1 = require("./option");
+const string_1 = require("./string");
+const tuple_1 = require("./tuple");
+function hostUserInfo(size) {
+ return (0, string_1.string)({ unit: (0, CharacterRangeArbitraryBuilder_1.getOrCreateAlphaNumericPercentArbitrary)("-._~!$&'()*+,;=:"), size });
+}
+function userHostPortMapper([u, h, p]) {
+ return (u === null ? '' : `${u}@`) + h + (p === null ? '' : `:${p}`);
+}
+function userHostPortUnmapper(value) {
+ if (typeof value !== 'string') {
+ throw new Error('Unsupported');
+ }
+ const atPosition = value.indexOf('@');
+ const user = atPosition !== -1 ? value.substring(0, atPosition) : null;
+ const portRegex = /:(\d+)$/;
+ const m = portRegex.exec(value);
+ const port = m !== null ? Number(m[1]) : null;
+ const host = m !== null ? value.substring(atPosition + 1, value.length - m[1].length - 1) : value.substring(atPosition + 1);
+ return [user, host, port];
+}
+function bracketedMapper(s) {
+ return `[${s}]`;
+}
+function bracketedUnmapper(value) {
+ if (typeof value !== 'string' || value[0] !== '[' || value[value.length - 1] !== ']') {
+ throw new Error('Unsupported');
+ }
+ return value.substring(1, value.length - 1);
+}
+function webAuthority(constraints) {
+ const c = constraints || {};
+ const size = c.size;
+ const hostnameArbs = [
+ (0, domain_1.domain)({ size }),
+ ...(c.withIPv4 === true ? [(0, ipV4_1.ipV4)()] : []),
+ ...(c.withIPv6 === true ? [(0, ipV6_1.ipV6)().map(bracketedMapper, bracketedUnmapper)] : []),
+ ...(c.withIPv4Extended === true ? [(0, ipV4Extended_1.ipV4Extended)()] : []),
+ ];
+ return (0, tuple_1.tuple)(c.withUserInfo === true ? (0, option_1.option)(hostUserInfo(size)) : (0, constant_1.constant)(null), (0, oneof_1.oneof)(...hostnameArbs), c.withPort === true ? (0, option_1.option)((0, nat_1.nat)(65535)) : (0, constant_1.constant)(null)).map(userHostPortMapper, userHostPortUnmapper);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/webFragments.js b/node_modules/fast-check/lib/arbitrary/webFragments.js
new file mode 100644
index 0000000000000000000000000000000000000000..3b90dc61c20ea590159fadb76ad9cd57757da8bf
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/webFragments.js
@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webFragments = webFragments;
+const UriQueryOrFragmentArbitraryBuilder_1 = require("./_internals/builders/UriQueryOrFragmentArbitraryBuilder");
+function webFragments(constraints = {}) {
+ return (0, UriQueryOrFragmentArbitraryBuilder_1.buildUriQueryOrFragmentArbitrary)(constraints.size);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/webPath.js b/node_modules/fast-check/lib/arbitrary/webPath.js
new file mode 100644
index 0000000000000000000000000000000000000000..58d2e0b99e14a202b32a25e13d2a09915f565a07
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/webPath.js
@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webPath = webPath;
+const MaxLengthFromMinLength_1 = require("./_internals/helpers/MaxLengthFromMinLength");
+const UriPathArbitraryBuilder_1 = require("./_internals/builders/UriPathArbitraryBuilder");
+function webPath(constraints) {
+ const c = constraints || {};
+ const resolvedSize = (0, MaxLengthFromMinLength_1.resolveSize)(c.size);
+ return (0, UriPathArbitraryBuilder_1.buildUriPathArbitrary)(resolvedSize);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/webQueryParameters.js b/node_modules/fast-check/lib/arbitrary/webQueryParameters.js
new file mode 100644
index 0000000000000000000000000000000000000000..40198e28c3a92c6203157077921c32d52431340e
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/webQueryParameters.js
@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webQueryParameters = webQueryParameters;
+const UriQueryOrFragmentArbitraryBuilder_1 = require("./_internals/builders/UriQueryOrFragmentArbitraryBuilder");
+function webQueryParameters(constraints = {}) {
+ return (0, UriQueryOrFragmentArbitraryBuilder_1.buildUriQueryOrFragmentArbitrary)(constraints.size);
+}
diff --git a/node_modules/fast-check/lib/arbitrary/webSegment.js b/node_modules/fast-check/lib/arbitrary/webSegment.js
new file mode 100644
index 0000000000000000000000000000000000000000..6184b682f8d18ddd060fb5845732c03150e86cb1
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/webSegment.js
@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webSegment = webSegment;
+const CharacterRangeArbitraryBuilder_1 = require("./_internals/builders/CharacterRangeArbitraryBuilder");
+const string_1 = require("./string");
+function webSegment(constraints = {}) {
+ return (0, string_1.string)({ unit: (0, CharacterRangeArbitraryBuilder_1.getOrCreateAlphaNumericPercentArbitrary)("-._~!$&'()*+,;=:@"), size: constraints.size });
+}
diff --git a/node_modules/fast-check/lib/arbitrary/webUrl.js b/node_modules/fast-check/lib/arbitrary/webUrl.js
new file mode 100644
index 0000000000000000000000000000000000000000..6b9392ae99c11d968f654f9806fd0fa2f67fdce4
--- /dev/null
+++ b/node_modules/fast-check/lib/arbitrary/webUrl.js
@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webUrl = webUrl;
+const constantFrom_1 = require("./constantFrom");
+const constant_1 = require("./constant");
+const option_1 = require("./option");
+const tuple_1 = require("./tuple");
+const webQueryParameters_1 = require("./webQueryParameters");
+const webFragments_1 = require("./webFragments");
+const webAuthority_1 = require("./webAuthority");
+const PartsToUrl_1 = require("./_internals/mappers/PartsToUrl");
+const MaxLengthFromMinLength_1 = require("./_internals/helpers/MaxLengthFromMinLength");
+const webPath_1 = require("./webPath");
+const safeObjectAssign = Object.assign;
+function webUrl(constraints) {
+ const c = constraints || {};
+ const resolvedSize = (0, MaxLengthFromMinLength_1.resolveSize)(c.size);
+ const resolvedAuthoritySettingsSize = c.authoritySettings !== undefined && c.authoritySettings.size !== undefined
+ ? (0, MaxLengthFromMinLength_1.relativeSizeToSize)(c.authoritySettings.size, resolvedSize)
+ : resolvedSize;
+ const resolvedAuthoritySettings = safeObjectAssign(safeObjectAssign({}, c.authoritySettings), {
+ size: resolvedAuthoritySettingsSize,
+ });
+ const validSchemes = c.validSchemes || ['http', 'https'];
+ const schemeArb = (0, constantFrom_1.constantFrom)(...validSchemes);
+ const authorityArb = (0, webAuthority_1.webAuthority)(resolvedAuthoritySettings);
+ return (0, tuple_1.tuple)(schemeArb, authorityArb, (0, webPath_1.webPath)({ size: resolvedSize }), c.withQueryParameters === true ? (0, option_1.option)((0, webQueryParameters_1.webQueryParameters)({ size: resolvedSize })) : (0, constant_1.constant)(null), c.withFragments === true ? (0, option_1.option)((0, webFragments_1.webFragments)({ size: resolvedSize })) : (0, constant_1.constant)(null)).map(PartsToUrl_1.partsToUrlMapper, PartsToUrl_1.partsToUrlUnmapper);
+}
diff --git a/node_modules/fast-check/lib/check/arbitrary/definition/Arbitrary.js b/node_modules/fast-check/lib/check/arbitrary/definition/Arbitrary.js
new file mode 100644
index 0000000000000000000000000000000000000000..9f8e5d4ac2d94921f490468ca8bca6b90074c4a1
--- /dev/null
+++ b/node_modules/fast-check/lib/check/arbitrary/definition/Arbitrary.js
@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Arbitrary = void 0;
+exports.isArbitrary = isArbitrary;
+exports.assertIsArbitrary = assertIsArbitrary;
+const Stream_1 = require("../../../stream/Stream");
+const symbols_1 = require("../../symbols");
+const Value_1 = require("./Value");
+const safeObjectAssign = Object.assign;
+class Arbitrary {
+ filter(refinement) {
+ return new FilterArbitrary(this, refinement);
+ }
+ map(mapper, unmapper) {
+ return new MapArbitrary(this, mapper, unmapper);
+ }
+ chain(chainer) {
+ return new ChainArbitrary(this, chainer);
+ }
+ noShrink() {
+ return new NoShrinkArbitrary(this);
+ }
+ noBias() {
+ return new NoBiasArbitrary(this);
+ }
+}
+exports.Arbitrary = Arbitrary;
+class ChainArbitrary extends Arbitrary {
+ constructor(arb, chainer) {
+ super();
+ this.arb = arb;
+ this.chainer = chainer;
+ }
+ generate(mrng, biasFactor) {
+ const clonedMrng = mrng.clone();
+ const src = this.arb.generate(mrng, biasFactor);
+ return this.valueChainer(src, mrng, clonedMrng, biasFactor);
+ }
+ canShrinkWithoutContext(value) {
+ return false;
+ }
+ shrink(value, context) {
+ if (this.isSafeContext(context)) {
+ return (!context.stoppedForOriginal
+ ? this.arb
+ .shrink(context.originalValue, context.originalContext)
+ .map((v) => this.valueChainer(v, context.clonedMrng.clone(), context.clonedMrng, context.originalBias))
+ : Stream_1.Stream.nil()).join(context.chainedArbitrary.shrink(value, context.chainedContext).map((dst) => {
+ const newContext = safeObjectAssign(safeObjectAssign({}, context), {
+ chainedContext: dst.context,
+ stoppedForOriginal: true,
+ });
+ return new Value_1.Value(dst.value_, newContext);
+ }));
+ }
+ return Stream_1.Stream.nil();
+ }
+ valueChainer(v, generateMrng, clonedMrng, biasFactor) {
+ const chainedArbitrary = this.chainer(v.value_);
+ const dst = chainedArbitrary.generate(generateMrng, biasFactor);
+ const context = {
+ originalBias: biasFactor,
+ originalValue: v.value_,
+ originalContext: v.context,
+ stoppedForOriginal: false,
+ chainedArbitrary,
+ chainedContext: dst.context,
+ clonedMrng,
+ };
+ return new Value_1.Value(dst.value_, context);
+ }
+ isSafeContext(context) {
+ return (context != null &&
+ typeof context === 'object' &&
+ 'originalBias' in context &&
+ 'originalValue' in context &&
+ 'originalContext' in context &&
+ 'stoppedForOriginal' in context &&
+ 'chainedArbitrary' in context &&
+ 'chainedContext' in context &&
+ 'clonedMrng' in context);
+ }
+}
+class MapArbitrary extends Arbitrary {
+ constructor(arb, mapper, unmapper) {
+ super();
+ this.arb = arb;
+ this.mapper = mapper;
+ this.unmapper = unmapper;
+ this.bindValueMapper = (v) => this.valueMapper(v);
+ }
+ generate(mrng, biasFactor) {
+ const g = this.arb.generate(mrng, biasFactor);
+ return this.valueMapper(g);
+ }
+ canShrinkWithoutContext(value) {
+ if (this.unmapper !== undefined) {
+ try {
+ const unmapped = this.unmapper(value);
+ return this.arb.canShrinkWithoutContext(unmapped);
+ }
+ catch (_err) {
+ return false;
+ }
+ }
+ return false;
+ }
+ shrink(value, context) {
+ if (this.isSafeContext(context)) {
+ return this.arb.shrink(context.originalValue, context.originalContext).map(this.bindValueMapper);
+ }
+ if (this.unmapper !== undefined) {
+ const unmapped = this.unmapper(value);
+ return this.arb.shrink(unmapped, undefined).map(this.bindValueMapper);
+ }
+ return Stream_1.Stream.nil();
+ }
+ mapperWithCloneIfNeeded(v) {
+ const sourceValue = v.value;
+ const mappedValue = this.mapper(sourceValue);
+ if (v.hasToBeCloned &&
+ ((typeof mappedValue === 'object' && mappedValue !== null) || typeof mappedValue === 'function') &&
+ Object.isExtensible(mappedValue) &&
+ !(0, symbols_1.hasCloneMethod)(mappedValue)) {
+ Object.defineProperty(mappedValue, symbols_1.cloneMethod, { get: () => () => this.mapperWithCloneIfNeeded(v)[0] });
+ }
+ return [mappedValue, sourceValue];
+ }
+ valueMapper(v) {
+ const [mappedValue, sourceValue] = this.mapperWithCloneIfNeeded(v);
+ const context = { originalValue: sourceValue, originalContext: v.context };
+ return new Value_1.Value(mappedValue, context);
+ }
+ isSafeContext(context) {
+ return (context != null &&
+ typeof context === 'object' &&
+ 'originalValue' in context &&
+ 'originalContext' in context);
+ }
+}
+class FilterArbitrary extends Arbitrary {
+ constructor(arb, refinement) {
+ super();
+ this.arb = arb;
+ this.refinement = refinement;
+ this.bindRefinementOnValue = (v) => this.refinementOnValue(v);
+ }
+ generate(mrng, biasFactor) {
+ while (true) {
+ const g = this.arb.generate(mrng, biasFactor);
+ if (this.refinementOnValue(g)) {
+ return g;
+ }
+ }
+ }
+ canShrinkWithoutContext(value) {
+ return this.arb.canShrinkWithoutContext(value) && this.refinement(value);
+ }
+ shrink(value, context) {
+ return this.arb.shrink(value, context).filter(this.bindRefinementOnValue);
+ }
+ refinementOnValue(v) {
+ return this.refinement(v.value);
+ }
+}
+class NoShrinkArbitrary extends Arbitrary {
+ constructor(arb) {
+ super();
+ this.arb = arb;
+ }
+ generate(mrng, biasFactor) {
+ return this.arb.generate(mrng, biasFactor);
+ }
+ canShrinkWithoutContext(value) {
+ return this.arb.canShrinkWithoutContext(value);
+ }
+ shrink(_value, _context) {
+ return Stream_1.Stream.nil();
+ }
+ noShrink() {
+ return this;
+ }
+}
+class NoBiasArbitrary extends Arbitrary {
+ constructor(arb) {
+ super();
+ this.arb = arb;
+ }
+ generate(mrng, _biasFactor) {
+ return this.arb.generate(mrng, undefined);
+ }
+ canShrinkWithoutContext(value) {
+ return this.arb.canShrinkWithoutContext(value);
+ }
+ shrink(value, context) {
+ return this.arb.shrink(value, context);
+ }
+ noBias() {
+ return this;
+ }
+}
+function isArbitrary(instance) {
+ return (typeof instance === 'object' &&
+ instance !== null &&
+ 'generate' in instance &&
+ 'shrink' in instance &&
+ 'canShrinkWithoutContext' in instance);
+}
+function assertIsArbitrary(instance) {
+ if (!isArbitrary(instance)) {
+ throw new Error('Unexpected value received: not an instance of Arbitrary');
+ }
+}
diff --git a/node_modules/fast-check/lib/check/arbitrary/definition/Value.js b/node_modules/fast-check/lib/check/arbitrary/definition/Value.js
new file mode 100644
index 0000000000000000000000000000000000000000..6cdfe2ad8eca30a6eff0b154efd5a0d7411b665b
--- /dev/null
+++ b/node_modules/fast-check/lib/check/arbitrary/definition/Value.js
@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Value = void 0;
+const symbols_1 = require("../../symbols");
+const safeObjectDefineProperty = Object.defineProperty;
+class Value {
+ constructor(value_, context, customGetValue = undefined) {
+ this.value_ = value_;
+ this.context = context;
+ this.hasToBeCloned = customGetValue !== undefined || (0, symbols_1.hasCloneMethod)(value_);
+ this.readOnce = false;
+ if (this.hasToBeCloned) {
+ safeObjectDefineProperty(this, 'value', { get: customGetValue !== undefined ? customGetValue : this.getValue });
+ }
+ else {
+ this.value = value_;
+ }
+ }
+ getValue() {
+ if (this.hasToBeCloned) {
+ if (!this.readOnce) {
+ this.readOnce = true;
+ return this.value_;
+ }
+ return this.value_[symbols_1.cloneMethod]();
+ }
+ return this.value_;
+ }
+}
+exports.Value = Value;
diff --git a/node_modules/fast-check/lib/check/model/ModelRunner.js b/node_modules/fast-check/lib/check/model/ModelRunner.js
new file mode 100644
index 0000000000000000000000000000000000000000..dc3c65dabfc7081be9c6a6e2115672991715b948
--- /dev/null
+++ b/node_modules/fast-check/lib/check/model/ModelRunner.js
@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.modelRun = modelRun;
+exports.asyncModelRun = asyncModelRun;
+exports.scheduledModelRun = scheduledModelRun;
+const ScheduledCommand_1 = require("./commands/ScheduledCommand");
+const genericModelRun = (s, cmds, initialValue, runCmd, then) => {
+ return s.then((o) => {
+ const { model, real } = o;
+ let state = initialValue;
+ for (const c of cmds) {
+ state = then(state, () => {
+ return runCmd(c, model, real);
+ });
+ }
+ return state;
+ });
+};
+const internalModelRun = (s, cmds) => {
+ const then = (_p, c) => c();
+ const setupProducer = {
+ then: (fun) => {
+ fun(s());
+ return undefined;
+ },
+ };
+ const runSync = (cmd, m, r) => {
+ if (cmd.check(m))
+ cmd.run(m, r);
+ return undefined;
+ };
+ return genericModelRun(setupProducer, cmds, undefined, runSync, then);
+};
+const isAsyncSetup = (s) => {
+ return typeof s.then === 'function';
+};
+const internalAsyncModelRun = async (s, cmds, defaultPromise = Promise.resolve()) => {
+ const then = (p, c) => p.then(c);
+ const setupProducer = {
+ then: (fun) => {
+ const out = s();
+ if (isAsyncSetup(out))
+ return out.then(fun);
+ else
+ return fun(out);
+ },
+ };
+ const runAsync = async (cmd, m, r) => {
+ if (await cmd.check(m))
+ await cmd.run(m, r);
+ };
+ return await genericModelRun(setupProducer, cmds, defaultPromise, runAsync, then);
+};
+function modelRun(s, cmds) {
+ internalModelRun(s, cmds);
+}
+async function asyncModelRun(s, cmds) {
+ await internalAsyncModelRun(s, cmds);
+}
+async function scheduledModelRun(scheduler, s, cmds) {
+ const scheduledCommands = (0, ScheduledCommand_1.scheduleCommands)(scheduler, cmds);
+ const out = internalAsyncModelRun(s, scheduledCommands, scheduler.schedule(Promise.resolve(), 'startModel'));
+ await scheduler.waitFor(out);
+ await scheduler.waitAll();
+}
diff --git a/node_modules/fast-check/lib/check/model/ReplayPath.js b/node_modules/fast-check/lib/check/model/ReplayPath.js
new file mode 100644
index 0000000000000000000000000000000000000000..c74e0aa2ea667d163dee263828838f40292d6b23
--- /dev/null
+++ b/node_modules/fast-check/lib/check/model/ReplayPath.js
@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplayPath = void 0;
+class ReplayPath {
+ static parse(replayPathStr) {
+ const [serializedCount, serializedChanges] = replayPathStr.split(':');
+ const counts = this.parseCounts(serializedCount);
+ const changes = this.parseChanges(serializedChanges);
+ return this.parseOccurences(counts, changes);
+ }
+ static stringify(replayPath) {
+ const occurences = this.countOccurences(replayPath);
+ const serializedCount = this.stringifyCounts(occurences);
+ const serializedChanges = this.stringifyChanges(occurences);
+ return `${serializedCount}:${serializedChanges}`;
+ }
+ static intToB64(n) {
+ if (n < 26)
+ return String.fromCharCode(n + 65);
+ if (n < 52)
+ return String.fromCharCode(n + 97 - 26);
+ if (n < 62)
+ return String.fromCharCode(n + 48 - 52);
+ return String.fromCharCode(n === 62 ? 43 : 47);
+ }
+ static b64ToInt(c) {
+ if (c >= 'a')
+ return c.charCodeAt(0) - 97 + 26;
+ if (c >= 'A')
+ return c.charCodeAt(0) - 65;
+ if (c >= '0')
+ return c.charCodeAt(0) - 48 + 52;
+ return c === '+' ? 62 : 63;
+ }
+ static countOccurences(replayPath) {
+ return replayPath.reduce((counts, cur) => {
+ if (counts.length === 0 || counts[counts.length - 1].count === 64 || counts[counts.length - 1].value !== cur)
+ counts.push({ value: cur, count: 1 });
+ else
+ counts[counts.length - 1].count += 1;
+ return counts;
+ }, []);
+ }
+ static parseOccurences(counts, changes) {
+ const replayPath = [];
+ for (let idx = 0; idx !== counts.length; ++idx) {
+ const count = counts[idx];
+ const value = changes[idx];
+ for (let num = 0; num !== count; ++num)
+ replayPath.push(value);
+ }
+ return replayPath;
+ }
+ static stringifyChanges(occurences) {
+ let serializedChanges = '';
+ for (let idx = 0; idx < occurences.length; idx += 6) {
+ const changesInt = occurences
+ .slice(idx, idx + 6)
+ .reduceRight((prev, cur) => prev * 2 + (cur.value ? 1 : 0), 0);
+ serializedChanges += this.intToB64(changesInt);
+ }
+ return serializedChanges;
+ }
+ static parseChanges(serializedChanges) {
+ const changesInt = serializedChanges.split('').map((c) => this.b64ToInt(c));
+ const changes = [];
+ for (let idx = 0; idx !== changesInt.length; ++idx) {
+ let current = changesInt[idx];
+ for (let n = 0; n !== 6; ++n, current >>= 1) {
+ changes.push(current % 2 === 1);
+ }
+ }
+ return changes;
+ }
+ static stringifyCounts(occurences) {
+ return occurences.map(({ count }) => this.intToB64(count - 1)).join('');
+ }
+ static parseCounts(serializedCount) {
+ return serializedCount.split('').map((c) => this.b64ToInt(c) + 1);
+ }
+}
+exports.ReplayPath = ReplayPath;
diff --git a/node_modules/fast-check/lib/check/model/command/AsyncCommand.js b/node_modules/fast-check/lib/check/model/command/AsyncCommand.js
new file mode 100644
index 0000000000000000000000000000000000000000..c8ad2e549bdc6801e0d1c80b0308d4b9bd4985ce
--- /dev/null
+++ b/node_modules/fast-check/lib/check/model/command/AsyncCommand.js
@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
diff --git a/node_modules/fast-check/lib/check/model/command/Command.js b/node_modules/fast-check/lib/check/model/command/Command.js
new file mode 100644
index 0000000000000000000000000000000000000000..c8ad2e549bdc6801e0d1c80b0308d4b9bd4985ce
--- /dev/null
+++ b/node_modules/fast-check/lib/check/model/command/Command.js
@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
diff --git a/node_modules/fast-check/lib/check/model/command/ICommand.js b/node_modules/fast-check/lib/check/model/command/ICommand.js
new file mode 100644
index 0000000000000000000000000000000000000000..c8ad2e549bdc6801e0d1c80b0308d4b9bd4985ce
--- /dev/null
+++ b/node_modules/fast-check/lib/check/model/command/ICommand.js
@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
diff --git a/node_modules/fast-check/lib/check/model/commands/CommandWrapper.js b/node_modules/fast-check/lib/check/model/commands/CommandWrapper.js
new file mode 100644
index 0000000000000000000000000000000000000000..83e98b64373ec0aa4d2d5311dbb1f148b6c4b9f3
--- /dev/null
+++ b/node_modules/fast-check/lib/check/model/commands/CommandWrapper.js
@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandWrapper = void 0;
+const stringify_1 = require("../../../utils/stringify");
+const symbols_1 = require("../../symbols");
+class CommandWrapper {
+ constructor(cmd) {
+ this.cmd = cmd;
+ this.hasRan = false;
+ if ((0, stringify_1.hasToStringMethod)(cmd)) {
+ const method = cmd[stringify_1.toStringMethod];
+ this[stringify_1.toStringMethod] = function toStringMethod() {
+ return method.call(cmd);
+ };
+ }
+ if ((0, stringify_1.hasAsyncToStringMethod)(cmd)) {
+ const method = cmd[stringify_1.asyncToStringMethod];
+ this[stringify_1.asyncToStringMethod] = function asyncToStringMethod() {
+ return method.call(cmd);
+ };
+ }
+ }
+ check(m) {
+ return this.cmd.check(m);
+ }
+ run(m, r) {
+ this.hasRan = true;
+ return this.cmd.run(m, r);
+ }
+ clone() {
+ if ((0, symbols_1.hasCloneMethod)(this.cmd))
+ return new CommandWrapper(this.cmd[symbols_1.cloneMethod]());
+ return new CommandWrapper(this.cmd);
+ }
+ toString() {
+ return this.cmd.toString();
+ }
+}
+exports.CommandWrapper = CommandWrapper;
diff --git a/node_modules/fast-check/lib/check/model/commands/CommandsContraints.js b/node_modules/fast-check/lib/check/model/commands/CommandsContraints.js
new file mode 100644
index 0000000000000000000000000000000000000000..c8ad2e549bdc6801e0d1c80b0308d4b9bd4985ce
--- /dev/null
+++ b/node_modules/fast-check/lib/check/model/commands/CommandsContraints.js
@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
diff --git a/node_modules/fast-check/lib/check/model/commands/CommandsIterable.js b/node_modules/fast-check/lib/check/model/commands/CommandsIterable.js
new file mode 100644
index 0000000000000000000000000000000000000000..e2f77251605639ea35e7a5440f15ebec6c035654
--- /dev/null
+++ b/node_modules/fast-check/lib/check/model/commands/CommandsIterable.js
@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandsIterable = void 0;
+const symbols_1 = require("../../symbols");
+class CommandsIterable {
+ constructor(commands, metadataForReplay) {
+ this.commands = commands;
+ this.metadataForReplay = metadataForReplay;
+ }
+ [Symbol.iterator]() {
+ return this.commands[Symbol.iterator]();
+ }
+ [symbols_1.cloneMethod]() {
+ return new CommandsIterable(this.commands.map((c) => c.clone()), this.metadataForReplay);
+ }
+ toString() {
+ const serializedCommands = this.commands
+ .filter((c) => c.hasRan)
+ .map((c) => c.toString())
+ .join(',');
+ const metadata = this.metadataForReplay();
+ return metadata.length !== 0 ? `${serializedCommands} /*${metadata}*/` : serializedCommands;
+ }
+}
+exports.CommandsIterable = CommandsIterable;
diff --git a/node_modules/fast-check/lib/check/model/commands/ScheduledCommand.js b/node_modules/fast-check/lib/check/model/commands/ScheduledCommand.js
new file mode 100644
index 0000000000000000000000000000000000000000..f2e33e2848ff8072246e459a98bf767a235caf3a
--- /dev/null
+++ b/node_modules/fast-check/lib/check/model/commands/ScheduledCommand.js
@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scheduleCommands = exports.ScheduledCommand = void 0;
+class ScheduledCommand {
+ constructor(s, cmd) {
+ this.s = s;
+ this.cmd = cmd;
+ }
+ async check(m) {
+ let error = null;
+ let checkPassed = false;
+ const status = await this.s.scheduleSequence([
+ {
+ label: `check@${this.cmd.toString()}`,
+ builder: async () => {
+ try {
+ checkPassed = await Promise.resolve(this.cmd.check(m));
+ }
+ catch (err) {
+ error = err;
+ throw err;
+ }
+ },
+ },
+ ]).task;
+ if (status.faulty) {
+ throw error;
+ }
+ return checkPassed;
+ }
+ async run(m, r) {
+ let error = null;
+ const status = await this.s.scheduleSequence([
+ {
+ label: `run@${this.cmd.toString()}`,
+ builder: async () => {
+ try {
+ await this.cmd.run(m, r);
+ }
+ catch (err) {
+ error = err;
+ throw err;
+ }
+ },
+ },
+ ]).task;
+ if (status.faulty) {
+ throw error;
+ }
+ }
+}
+exports.ScheduledCommand = ScheduledCommand;
+const scheduleCommands = function* (s, cmds) {
+ for (const cmd of cmds) {
+ yield new ScheduledCommand(s, cmd);
+ }
+};
+exports.scheduleCommands = scheduleCommands;
diff --git a/node_modules/fast-check/lib/check/precondition/Pre.js b/node_modules/fast-check/lib/check/precondition/Pre.js
new file mode 100644
index 0000000000000000000000000000000000000000..de03e5995efa424cf5bc2c86f90703d460c3e173
--- /dev/null
+++ b/node_modules/fast-check/lib/check/precondition/Pre.js
@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pre = pre;
+const PreconditionFailure_1 = require("./PreconditionFailure");
+function pre(expectTruthy) {
+ if (!expectTruthy) {
+ throw new PreconditionFailure_1.PreconditionFailure();
+ }
+}
diff --git a/node_modules/fast-check/lib/check/precondition/PreconditionFailure.js b/node_modules/fast-check/lib/check/precondition/PreconditionFailure.js
new file mode 100644
index 0000000000000000000000000000000000000000..82501a28ff8d760d799ec3def148c82bdcd4406f
--- /dev/null
+++ b/node_modules/fast-check/lib/check/precondition/PreconditionFailure.js
@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreconditionFailure = void 0;
+class PreconditionFailure extends Error {
+ constructor(interruptExecution = false) {
+ super();
+ this.interruptExecution = interruptExecution;
+ this.footprint = PreconditionFailure.SharedFootPrint;
+ }
+ static isFailure(err) {
+ return err != null && err.footprint === PreconditionFailure.SharedFootPrint;
+ }
+}
+exports.PreconditionFailure = PreconditionFailure;
+PreconditionFailure.SharedFootPrint = Symbol.for('fast-check/PreconditionFailure');
diff --git a/node_modules/fast-check/lib/check/property/AsyncProperty.generic.js b/node_modules/fast-check/lib/check/property/AsyncProperty.generic.js
new file mode 100644
index 0000000000000000000000000000000000000000..46f72144b4f1b5a1b0fd295f0f65f27149595a39
--- /dev/null
+++ b/node_modules/fast-check/lib/check/property/AsyncProperty.generic.js
@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncProperty = void 0;
+const PreconditionFailure_1 = require("../precondition/PreconditionFailure");
+const IRawProperty_1 = require("./IRawProperty");
+const GlobalParameters_1 = require("../runner/configuration/GlobalParameters");
+const Stream_1 = require("../../stream/Stream");
+const NoUndefinedAsContext_1 = require("../../arbitrary/_internals/helpers/NoUndefinedAsContext");
+const globals_1 = require("../../utils/globals");
+class AsyncProperty {
+ constructor(arb, predicate) {
+ this.arb = arb;
+ this.predicate = predicate;
+ const { asyncBeforeEach, asyncAfterEach, beforeEach, afterEach } = (0, GlobalParameters_1.readConfigureGlobal)() || {};
+ if (asyncBeforeEach !== undefined && beforeEach !== undefined) {
+ throw (0, globals_1.Error)('Global "asyncBeforeEach" and "beforeEach" parameters can\'t be set at the same time when running async properties');
+ }
+ if (asyncAfterEach !== undefined && afterEach !== undefined) {
+ throw (0, globals_1.Error)('Global "asyncAfterEach" and "afterEach" parameters can\'t be set at the same time when running async properties');
+ }
+ this.beforeEachHook = asyncBeforeEach || beforeEach || AsyncProperty.dummyHook;
+ this.afterEachHook = asyncAfterEach || afterEach || AsyncProperty.dummyHook;
+ }
+ isAsync() {
+ return true;
+ }
+ generate(mrng, runId) {
+ const value = this.arb.generate(mrng, runId != null ? (0, IRawProperty_1.runIdToFrequency)(runId) : undefined);
+ return (0, NoUndefinedAsContext_1.noUndefinedAsContext)(value);
+ }
+ shrink(value) {
+ if (value.context === undefined && !this.arb.canShrinkWithoutContext(value.value_)) {
+ return Stream_1.Stream.nil();
+ }
+ const safeContext = value.context !== NoUndefinedAsContext_1.UndefinedContextPlaceholder ? value.context : undefined;
+ return this.arb.shrink(value.value_, safeContext).map(NoUndefinedAsContext_1.noUndefinedAsContext);
+ }
+ async runBeforeEach() {
+ await this.beforeEachHook();
+ }
+ async runAfterEach() {
+ await this.afterEachHook();
+ }
+ async run(v, dontRunHook) {
+ if (!dontRunHook) {
+ await this.beforeEachHook();
+ }
+ try {
+ const output = await this.predicate(v);
+ return output == null || output === true
+ ? null
+ : {
+ error: new globals_1.Error('Property failed by returning false'),
+ errorMessage: 'Error: Property failed by returning false',
+ };
+ }
+ catch (err) {
+ if (PreconditionFailure_1.PreconditionFailure.isFailure(err))
+ return err;
+ if (err instanceof globals_1.Error && err.stack) {
+ return { error: err, errorMessage: err.stack };
+ }
+ return { error: err, errorMessage: (0, globals_1.String)(err) };
+ }
+ finally {
+ if (!dontRunHook) {
+ await this.afterEachHook();
+ }
+ }
+ }
+ beforeEach(hookFunction) {
+ const previousBeforeEachHook = this.beforeEachHook;
+ this.beforeEachHook = () => hookFunction(previousBeforeEachHook);
+ return this;
+ }
+ afterEach(hookFunction) {
+ const previousAfterEachHook = this.afterEachHook;
+ this.afterEachHook = () => hookFunction(previousAfterEachHook);
+ return this;
+ }
+}
+exports.AsyncProperty = AsyncProperty;
+AsyncProperty.dummyHook = () => { };
diff --git a/node_modules/fast-check/lib/check/property/AsyncProperty.js b/node_modules/fast-check/lib/check/property/AsyncProperty.js
new file mode 100644
index 0000000000000000000000000000000000000000..6eb3de3bef84ef5af8aa2421189aa93a76943627
--- /dev/null
+++ b/node_modules/fast-check/lib/check/property/AsyncProperty.js
@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asyncProperty = asyncProperty;
+const Arbitrary_1 = require("../arbitrary/definition/Arbitrary");
+const tuple_1 = require("../../arbitrary/tuple");
+const AsyncProperty_generic_1 = require("./AsyncProperty.generic");
+const AlwaysShrinkableArbitrary_1 = require("../../arbitrary/_internals/AlwaysShrinkableArbitrary");
+const globals_1 = require("../../utils/globals");
+function asyncProperty(...args) {
+ if (args.length < 2) {
+ throw new Error('asyncProperty expects at least two parameters');
+ }
+ const arbs = (0, globals_1.safeSlice)(args, 0, args.length - 1);
+ const p = args[args.length - 1];
+ (0, globals_1.safeForEach)(arbs, Arbitrary_1.assertIsArbitrary);
+ const mappedArbs = (0, globals_1.safeMap)(arbs, (arb) => new AlwaysShrinkableArbitrary_1.AlwaysShrinkableArbitrary(arb));
+ return new AsyncProperty_generic_1.AsyncProperty((0, tuple_1.tuple)(...mappedArbs), (t) => p(...t));
+}
diff --git a/node_modules/fast-check/lib/check/property/IRawProperty.js b/node_modules/fast-check/lib/check/property/IRawProperty.js
new file mode 100644
index 0000000000000000000000000000000000000000..f10fcdb66016ade984953b1916e7f757ffc5e28b
--- /dev/null
+++ b/node_modules/fast-check/lib/check/property/IRawProperty.js
@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runIdToFrequency = runIdToFrequency;
+const safeMathLog = Math.log;
+function runIdToFrequency(runId) {
+ return 2 + ~~(safeMathLog(runId + 1) * 0.4342944819032518);
+}
diff --git a/node_modules/fast-check/lib/check/property/IgnoreEqualValuesProperty.js b/node_modules/fast-check/lib/check/property/IgnoreEqualValuesProperty.js
new file mode 100644
index 0000000000000000000000000000000000000000..bf21a0564c5db3c13fbb5c769cbcc698c730e6bf
--- /dev/null
+++ b/node_modules/fast-check/lib/check/property/IgnoreEqualValuesProperty.js
@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IgnoreEqualValuesProperty = void 0;
+const stringify_1 = require("../../utils/stringify");
+const PreconditionFailure_1 = require("../precondition/PreconditionFailure");
+function fromSyncCached(cachedValue) {
+ return cachedValue === null ? new PreconditionFailure_1.PreconditionFailure() : cachedValue;
+}
+function fromCached(...data) {
+ if (data[1])
+ return data[0].then(fromSyncCached);
+ return fromSyncCached(data[0]);
+}
+function fromCachedUnsafe(cachedValue, isAsync) {
+ return fromCached(cachedValue, isAsync);
+}
+class IgnoreEqualValuesProperty {
+ constructor(property, skipRuns) {
+ this.property = property;
+ this.skipRuns = skipRuns;
+ this.coveredCases = new Map();
+ if (this.property.runBeforeEach !== undefined && this.property.runAfterEach !== undefined) {
+ this.runBeforeEach = () => this.property.runBeforeEach();
+ this.runAfterEach = () => this.property.runAfterEach();
+ }
+ }
+ isAsync() {
+ return this.property.isAsync();
+ }
+ generate(mrng, runId) {
+ return this.property.generate(mrng, runId);
+ }
+ shrink(value) {
+ return this.property.shrink(value);
+ }
+ run(v, dontRunHook) {
+ const stringifiedValue = (0, stringify_1.stringify)(v);
+ if (this.coveredCases.has(stringifiedValue)) {
+ const lastOutput = this.coveredCases.get(stringifiedValue);
+ if (!this.skipRuns) {
+ return lastOutput;
+ }
+ return fromCachedUnsafe(lastOutput, this.property.isAsync());
+ }
+ const out = this.property.run(v, dontRunHook);
+ this.coveredCases.set(stringifiedValue, out);
+ return out;
+ }
+}
+exports.IgnoreEqualValuesProperty = IgnoreEqualValuesProperty;
diff --git a/node_modules/fast-check/lib/check/property/Property.generic.js b/node_modules/fast-check/lib/check/property/Property.generic.js
new file mode 100644
index 0000000000000000000000000000000000000000..61a220662a5fbec2dd514d3fcac68be39f29fea7
--- /dev/null
+++ b/node_modules/fast-check/lib/check/property/Property.generic.js
@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Property = void 0;
+const PreconditionFailure_1 = require("../precondition/PreconditionFailure");
+const IRawProperty_1 = require("./IRawProperty");
+const GlobalParameters_1 = require("../runner/configuration/GlobalParameters");
+const Stream_1 = require("../../stream/Stream");
+const NoUndefinedAsContext_1 = require("../../arbitrary/_internals/helpers/NoUndefinedAsContext");
+const globals_1 = require("../../utils/globals");
+class Property {
+ constructor(arb, predicate) {
+ this.arb = arb;
+ this.predicate = predicate;
+ const { beforeEach = Property.dummyHook, afterEach = Property.dummyHook, asyncBeforeEach, asyncAfterEach, } = (0, GlobalParameters_1.readConfigureGlobal)() || {};
+ if (asyncBeforeEach !== undefined) {
+ throw (0, globals_1.Error)('"asyncBeforeEach" can\'t be set when running synchronous properties');
+ }
+ if (asyncAfterEach !== undefined) {
+ throw (0, globals_1.Error)('"asyncAfterEach" can\'t be set when running synchronous properties');
+ }
+ this.beforeEachHook = beforeEach;
+ this.afterEachHook = afterEach;
+ }
+ isAsync() {
+ return false;
+ }
+ generate(mrng, runId) {
+ const value = this.arb.generate(mrng, runId != null ? (0, IRawProperty_1.runIdToFrequency)(runId) : undefined);
+ return (0, NoUndefinedAsContext_1.noUndefinedAsContext)(value);
+ }
+ shrink(value) {
+ if (value.context === undefined && !this.arb.canShrinkWithoutContext(value.value_)) {
+ return Stream_1.Stream.nil();
+ }
+ const safeContext = value.context !== NoUndefinedAsContext_1.UndefinedContextPlaceholder ? value.context : undefined;
+ return this.arb.shrink(value.value_, safeContext).map(NoUndefinedAsContext_1.noUndefinedAsContext);
+ }
+ runBeforeEach() {
+ this.beforeEachHook();
+ }
+ runAfterEach() {
+ this.afterEachHook();
+ }
+ run(v, dontRunHook) {
+ if (!dontRunHook) {
+ this.beforeEachHook();
+ }
+ try {
+ const output = this.predicate(v);
+ return output == null || output === true
+ ? null
+ : {
+ error: new globals_1.Error('Property failed by returning false'),
+ errorMessage: 'Error: Property failed by returning false',
+ };
+ }
+ catch (err) {
+ if (PreconditionFailure_1.PreconditionFailure.isFailure(err))
+ return err;
+ if (err instanceof globals_1.Error && err.stack) {
+ return { error: err, errorMessage: err.stack };
+ }
+ return { error: err, errorMessage: (0, globals_1.String)(err) };
+ }
+ finally {
+ if (!dontRunHook) {
+ this.afterEachHook();
+ }
+ }
+ }
+ beforeEach(hookFunction) {
+ const previousBeforeEachHook = this.beforeEachHook;
+ this.beforeEachHook = () => hookFunction(previousBeforeEachHook);
+ return this;
+ }
+ afterEach(hookFunction) {
+ const previousAfterEachHook = this.afterEachHook;
+ this.afterEachHook = () => hookFunction(previousAfterEachHook);
+ return this;
+ }
+}
+exports.Property = Property;
+Property.dummyHook = () => { };
diff --git a/node_modules/fast-check/lib/check/property/Property.js b/node_modules/fast-check/lib/check/property/Property.js
new file mode 100644
index 0000000000000000000000000000000000000000..07aa2832fc0bfb458078d177481c61670c176535
--- /dev/null
+++ b/node_modules/fast-check/lib/check/property/Property.js
@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.property = property;
+const Arbitrary_1 = require("../arbitrary/definition/Arbitrary");
+const tuple_1 = require("../../arbitrary/tuple");
+const Property_generic_1 = require("./Property.generic");
+const AlwaysShrinkableArbitrary_1 = require("../../arbitrary/_internals/AlwaysShrinkableArbitrary");
+const globals_1 = require("../../utils/globals");
+function property(...args) {
+ if (args.length < 2) {
+ throw new Error('property expects at least two parameters');
+ }
+ const arbs = (0, globals_1.safeSlice)(args, 0, args.length - 1);
+ const p = args[args.length - 1];
+ (0, globals_1.safeForEach)(arbs, Arbitrary_1.assertIsArbitrary);
+ const mappedArbs = (0, globals_1.safeMap)(arbs, (arb) => new AlwaysShrinkableArbitrary_1.AlwaysShrinkableArbitrary(arb));
+ return new Property_generic_1.Property((0, tuple_1.tuple)(...mappedArbs), (t) => p(...t));
+}
diff --git a/node_modules/fast-check/lib/check/property/SkipAfterProperty.js b/node_modules/fast-check/lib/check/property/SkipAfterProperty.js
new file mode 100644
index 0000000000000000000000000000000000000000..e9e35cc1f9e2dbc88b8fba9e3fd19127c2eab898
--- /dev/null
+++ b/node_modules/fast-check/lib/check/property/SkipAfterProperty.js
@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkipAfterProperty = void 0;
+const PreconditionFailure_1 = require("../precondition/PreconditionFailure");
+function interruptAfter(timeMs, setTimeoutSafe, clearTimeoutSafe) {
+ let timeoutHandle = null;
+ const promise = new Promise((resolve) => {
+ timeoutHandle = setTimeoutSafe(() => {
+ const preconditionFailure = new PreconditionFailure_1.PreconditionFailure(true);
+ resolve(preconditionFailure);
+ }, timeMs);
+ });
+ return {
+ clear: () => clearTimeoutSafe(timeoutHandle),
+ promise,
+ };
+}
+class SkipAfterProperty {
+ constructor(property, getTime, timeLimit, interruptExecution, setTimeoutSafe, clearTimeoutSafe) {
+ this.property = property;
+ this.getTime = getTime;
+ this.interruptExecution = interruptExecution;
+ this.setTimeoutSafe = setTimeoutSafe;
+ this.clearTimeoutSafe = clearTimeoutSafe;
+ this.skipAfterTime = this.getTime() + timeLimit;
+ if (this.property.runBeforeEach !== undefined && this.property.runAfterEach !== undefined) {
+ this.runBeforeEach = () => this.property.runBeforeEach();
+ this.runAfterEach = () => this.property.runAfterEach();
+ }
+ }
+ isAsync() {
+ return this.property.isAsync();
+ }
+ generate(mrng, runId) {
+ return this.property.generate(mrng, runId);
+ }
+ shrink(value) {
+ return this.property.shrink(value);
+ }
+ run(v, dontRunHook) {
+ const remainingTime = this.skipAfterTime - this.getTime();
+ if (remainingTime <= 0) {
+ const preconditionFailure = new PreconditionFailure_1.PreconditionFailure(this.interruptExecution);
+ if (this.isAsync()) {
+ return Promise.resolve(preconditionFailure);
+ }
+ else {
+ return preconditionFailure;
+ }
+ }
+ if (this.interruptExecution && this.isAsync()) {
+ const t = interruptAfter(remainingTime, this.setTimeoutSafe, this.clearTimeoutSafe);
+ const propRun = Promise.race([this.property.run(v, dontRunHook), t.promise]);
+ propRun.then(t.clear, t.clear);
+ return propRun;
+ }
+ return this.property.run(v, dontRunHook);
+ }
+}
+exports.SkipAfterProperty = SkipAfterProperty;
diff --git a/node_modules/fast-check/lib/check/property/TimeoutProperty.js b/node_modules/fast-check/lib/check/property/TimeoutProperty.js
new file mode 100644
index 0000000000000000000000000000000000000000..d5ecdeec5813d1e36ba5bda8a9914daaba9e21aa
--- /dev/null
+++ b/node_modules/fast-check/lib/check/property/TimeoutProperty.js
@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeoutProperty = void 0;
+const globals_1 = require("../../utils/globals");
+const timeoutAfter = (timeMs, setTimeoutSafe, clearTimeoutSafe) => {
+ let timeoutHandle = null;
+ const promise = new Promise((resolve) => {
+ timeoutHandle = setTimeoutSafe(() => {
+ resolve({
+ error: new globals_1.Error(`Property timeout: exceeded limit of ${timeMs} milliseconds`),
+ errorMessage: `Property timeout: exceeded limit of ${timeMs} milliseconds`,
+ });
+ }, timeMs);
+ });
+ return {
+ clear: () => clearTimeoutSafe(timeoutHandle),
+ promise,
+ };
+};
+class TimeoutProperty {
+ constructor(property, timeMs, setTimeoutSafe, clearTimeoutSafe) {
+ this.property = property;
+ this.timeMs = timeMs;
+ this.setTimeoutSafe = setTimeoutSafe;
+ this.clearTimeoutSafe = clearTimeoutSafe;
+ if (this.property.runBeforeEach !== undefined && this.property.runAfterEach !== undefined) {
+ this.runBeforeEach = () => Promise.resolve(this.property.runBeforeEach());
+ this.runAfterEach = () => Promise.resolve(this.property.runAfterEach());
+ }
+ }
+ isAsync() {
+ return true;
+ }
+ generate(mrng, runId) {
+ return this.property.generate(mrng, runId);
+ }
+ shrink(value) {
+ return this.property.shrink(value);
+ }
+ async run(v, dontRunHook) {
+ const t = timeoutAfter(this.timeMs, this.setTimeoutSafe, this.clearTimeoutSafe);
+ const propRun = Promise.race([this.property.run(v, dontRunHook), t.promise]);
+ propRun.then(t.clear, t.clear);
+ return propRun;
+ }
+}
+exports.TimeoutProperty = TimeoutProperty;
diff --git a/node_modules/fast-check/lib/check/property/UnbiasedProperty.js b/node_modules/fast-check/lib/check/property/UnbiasedProperty.js
new file mode 100644
index 0000000000000000000000000000000000000000..eeb881428dc4dc4314086697b66ed8af25cff49c
--- /dev/null
+++ b/node_modules/fast-check/lib/check/property/UnbiasedProperty.js
@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnbiasedProperty = void 0;
+class UnbiasedProperty {
+ constructor(property) {
+ this.property = property;
+ if (this.property.runBeforeEach !== undefined && this.property.runAfterEach !== undefined) {
+ this.runBeforeEach = () => this.property.runBeforeEach();
+ this.runAfterEach = () => this.property.runAfterEach();
+ }
+ }
+ isAsync() {
+ return this.property.isAsync();
+ }
+ generate(mrng, _runId) {
+ return this.property.generate(mrng, undefined);
+ }
+ shrink(value) {
+ return this.property.shrink(value);
+ }
+ run(v, dontRunHook) {
+ return this.property.run(v, dontRunHook);
+ }
+}
+exports.UnbiasedProperty = UnbiasedProperty;
diff --git a/node_modules/fast-check/lib/check/runner/DecorateProperty.js b/node_modules/fast-check/lib/check/runner/DecorateProperty.js
new file mode 100644
index 0000000000000000000000000000000000000000..706c72204cd7caf65ba42bc368282355242fc7d9
--- /dev/null
+++ b/node_modules/fast-check/lib/check/runner/DecorateProperty.js
@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decorateProperty = decorateProperty;
+const SkipAfterProperty_1 = require("../property/SkipAfterProperty");
+const TimeoutProperty_1 = require("../property/TimeoutProperty");
+const UnbiasedProperty_1 = require("../property/UnbiasedProperty");
+const IgnoreEqualValuesProperty_1 = require("../property/IgnoreEqualValuesProperty");
+const safeDateNow = Date.now;
+const safeSetTimeout = setTimeout;
+const safeClearTimeout = clearTimeout;
+function decorateProperty(rawProperty, qParams) {
+ let prop = rawProperty;
+ if (rawProperty.isAsync() && qParams.timeout != null) {
+ prop = new TimeoutProperty_1.TimeoutProperty(prop, qParams.timeout, safeSetTimeout, safeClearTimeout);
+ }
+ if (qParams.unbiased) {
+ prop = new UnbiasedProperty_1.UnbiasedProperty(prop);
+ }
+ if (qParams.skipAllAfterTimeLimit != null) {
+ prop = new SkipAfterProperty_1.SkipAfterProperty(prop, safeDateNow, qParams.skipAllAfterTimeLimit, false, safeSetTimeout, safeClearTimeout);
+ }
+ if (qParams.interruptAfterTimeLimit != null) {
+ prop = new SkipAfterProperty_1.SkipAfterProperty(prop, safeDateNow, qParams.interruptAfterTimeLimit, true, safeSetTimeout, safeClearTimeout);
+ }
+ if (qParams.skipEqualValues) {
+ prop = new IgnoreEqualValuesProperty_1.IgnoreEqualValuesProperty(prop, true);
+ }
+ if (qParams.ignoreEqualValues) {
+ prop = new IgnoreEqualValuesProperty_1.IgnoreEqualValuesProperty(prop, false);
+ }
+ return prop;
+}
diff --git a/node_modules/fast-check/lib/check/runner/Runner.js b/node_modules/fast-check/lib/check/runner/Runner.js
new file mode 100644
index 0000000000000000000000000000000000000000..1dc3924dd3f925e9fae9e109bca69523008a3e92
--- /dev/null
+++ b/node_modules/fast-check/lib/check/runner/Runner.js
@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.check = check;
+exports.assert = assert;
+const Stream_1 = require("../../stream/Stream");
+const GlobalParameters_1 = require("./configuration/GlobalParameters");
+const QualifiedParameters_1 = require("./configuration/QualifiedParameters");
+const DecorateProperty_1 = require("./DecorateProperty");
+const RunnerIterator_1 = require("./RunnerIterator");
+const SourceValuesIterator_1 = require("./SourceValuesIterator");
+const Tosser_1 = require("./Tosser");
+const PathWalker_1 = require("./utils/PathWalker");
+const RunDetailsFormatter_1 = require("./utils/RunDetailsFormatter");
+const safeObjectAssign = Object.assign;
+function runIt(property, shrink, sourceValues, verbose, interruptedAsFailure) {
+ const isModernProperty = property.runBeforeEach !== undefined && property.runAfterEach !== undefined;
+ const runner = new RunnerIterator_1.RunnerIterator(sourceValues, shrink, verbose, interruptedAsFailure);
+ for (const v of runner) {
+ if (isModernProperty) {
+ property.runBeforeEach();
+ }
+ const out = property.run(v, isModernProperty);
+ if (isModernProperty) {
+ property.runAfterEach();
+ }
+ runner.handleResult(out);
+ }
+ return runner.runExecution;
+}
+async function asyncRunIt(property, shrink, sourceValues, verbose, interruptedAsFailure) {
+ const isModernProperty = property.runBeforeEach !== undefined && property.runAfterEach !== undefined;
+ const runner = new RunnerIterator_1.RunnerIterator(sourceValues, shrink, verbose, interruptedAsFailure);
+ for (const v of runner) {
+ if (isModernProperty) {
+ await property.runBeforeEach();
+ }
+ const out = await property.run(v, isModernProperty);
+ if (isModernProperty) {
+ await property.runAfterEach();
+ }
+ runner.handleResult(out);
+ }
+ return runner.runExecution;
+}
+function check(rawProperty, params) {
+ if (rawProperty == null || rawProperty.generate == null)
+ throw new Error('Invalid property encountered, please use a valid property');
+ if (rawProperty.run == null)
+ throw new Error('Invalid property encountered, please use a valid property not an arbitrary');
+ const qParams = QualifiedParameters_1.QualifiedParameters.read(safeObjectAssign(safeObjectAssign({}, (0, GlobalParameters_1.readConfigureGlobal)()), params));
+ if (qParams.reporter !== null && qParams.asyncReporter !== null)
+ throw new Error('Invalid parameters encountered, reporter and asyncReporter cannot be specified together');
+ if (qParams.asyncReporter !== null && !rawProperty.isAsync())
+ throw new Error('Invalid parameters encountered, only asyncProperty can be used when asyncReporter specified');
+ const property = (0, DecorateProperty_1.decorateProperty)(rawProperty, qParams);
+ const maxInitialIterations = qParams.path.length === 0 || qParams.path.indexOf(':') === -1 ? qParams.numRuns : -1;
+ const maxSkips = qParams.numRuns * qParams.maxSkipsPerRun;
+ const shrink = (...args) => property.shrink(...args);
+ const initialValues = qParams.path.length === 0
+ ? (0, Tosser_1.toss)(property, qParams.seed, qParams.randomType, qParams.examples)
+ : (0, PathWalker_1.pathWalk)(qParams.path, (0, Stream_1.stream)((0, Tosser_1.lazyToss)(property, qParams.seed, qParams.randomType, qParams.examples)), shrink);
+ const sourceValues = new SourceValuesIterator_1.SourceValuesIterator(initialValues, maxInitialIterations, maxSkips);
+ const finalShrink = !qParams.endOnFailure ? shrink : Stream_1.Stream.nil;
+ return property.isAsync()
+ ? asyncRunIt(property, finalShrink, sourceValues, qParams.verbose, qParams.markInterruptAsFailure).then((e) => e.toRunDetails(qParams.seed, qParams.path, maxSkips, qParams))
+ : runIt(property, finalShrink, sourceValues, qParams.verbose, qParams.markInterruptAsFailure).toRunDetails(qParams.seed, qParams.path, maxSkips, qParams);
+}
+function assert(property, params) {
+ const out = check(property, params);
+ if (property.isAsync())
+ return out.then(RunDetailsFormatter_1.asyncReportRunDetails);
+ else
+ (0, RunDetailsFormatter_1.reportRunDetails)(out);
+}
diff --git a/node_modules/fast-check/lib/check/runner/RunnerIterator.js b/node_modules/fast-check/lib/check/runner/RunnerIterator.js
new file mode 100644
index 0000000000000000000000000000000000000000..e502a36c1a57f5df3a1bb150a5a17e190eb7daaa
--- /dev/null
+++ b/node_modules/fast-check/lib/check/runner/RunnerIterator.js
@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunnerIterator = void 0;
+const PreconditionFailure_1 = require("../precondition/PreconditionFailure");
+const RunExecution_1 = require("./reporter/RunExecution");
+class RunnerIterator {
+ constructor(sourceValues, shrink, verbose, interruptedAsFailure) {
+ this.sourceValues = sourceValues;
+ this.shrink = shrink;
+ this.runExecution = new RunExecution_1.RunExecution(verbose, interruptedAsFailure);
+ this.currentIdx = -1;
+ this.nextValues = sourceValues;
+ }
+ [Symbol.iterator]() {
+ return this;
+ }
+ next() {
+ const nextValue = this.nextValues.next();
+ if (nextValue.done || this.runExecution.interrupted) {
+ return { done: true, value: undefined };
+ }
+ this.currentValue = nextValue.value;
+ ++this.currentIdx;
+ return { done: false, value: nextValue.value.value_ };
+ }
+ handleResult(result) {
+ if (result != null && typeof result === 'object' && !PreconditionFailure_1.PreconditionFailure.isFailure(result)) {
+ this.runExecution.fail(this.currentValue.value_, this.currentIdx, result);
+ this.currentIdx = -1;
+ this.nextValues = this.shrink(this.currentValue);
+ }
+ else if (result != null) {
+ if (!result.interruptExecution) {
+ this.runExecution.skip(this.currentValue.value_);
+ this.sourceValues.skippedOne();
+ }
+ else {
+ this.runExecution.interrupt();
+ }
+ }
+ else {
+ this.runExecution.success(this.currentValue.value_);
+ }
+ }
+}
+exports.RunnerIterator = RunnerIterator;
diff --git a/node_modules/fast-check/lib/check/runner/Sampler.js b/node_modules/fast-check/lib/check/runner/Sampler.js
new file mode 100644
index 0000000000000000000000000000000000000000..18bf8f369c82e142db665f091c62c166fa0bb337
--- /dev/null
+++ b/node_modules/fast-check/lib/check/runner/Sampler.js
@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sample = sample;
+exports.statistics = statistics;
+const Stream_1 = require("../../stream/Stream");
+const Property_generic_1 = require("../property/Property.generic");
+const UnbiasedProperty_1 = require("../property/UnbiasedProperty");
+const GlobalParameters_1 = require("./configuration/GlobalParameters");
+const QualifiedParameters_1 = require("./configuration/QualifiedParameters");
+const Tosser_1 = require("./Tosser");
+const PathWalker_1 = require("./utils/PathWalker");
+function toProperty(generator, qParams) {
+ const prop = !Object.prototype.hasOwnProperty.call(generator, 'isAsync')
+ ? new Property_generic_1.Property(generator, () => true)
+ : generator;
+ return qParams.unbiased === true ? new UnbiasedProperty_1.UnbiasedProperty(prop) : prop;
+}
+function streamSample(generator, params) {
+ const extendedParams = typeof params === 'number'
+ ? Object.assign(Object.assign({}, (0, GlobalParameters_1.readConfigureGlobal)()), { numRuns: params }) : Object.assign(Object.assign({}, (0, GlobalParameters_1.readConfigureGlobal)()), params);
+ const qParams = QualifiedParameters_1.QualifiedParameters.read(extendedParams);
+ const nextProperty = toProperty(generator, qParams);
+ const shrink = nextProperty.shrink.bind(nextProperty);
+ const tossedValues = qParams.path.length === 0
+ ? (0, Stream_1.stream)((0, Tosser_1.toss)(nextProperty, qParams.seed, qParams.randomType, qParams.examples))
+ : (0, PathWalker_1.pathWalk)(qParams.path, (0, Stream_1.stream)((0, Tosser_1.lazyToss)(nextProperty, qParams.seed, qParams.randomType, qParams.examples)), shrink);
+ return tossedValues.take(qParams.numRuns).map((s) => s.value_);
+}
+function sample(generator, params) {
+ return [...streamSample(generator, params)];
+}
+function round2(n) {
+ return (Math.round(n * 100) / 100).toFixed(2);
+}
+function statistics(generator, classify, params) {
+ const extendedParams = typeof params === 'number'
+ ? Object.assign(Object.assign({}, (0, GlobalParameters_1.readConfigureGlobal)()), { numRuns: params }) : Object.assign(Object.assign({}, (0, GlobalParameters_1.readConfigureGlobal)()), params);
+ const qParams = QualifiedParameters_1.QualifiedParameters.read(extendedParams);
+ const recorded = {};
+ for (const g of streamSample(generator, params)) {
+ const out = classify(g);
+ const categories = Array.isArray(out) ? out : [out];
+ for (const c of categories) {
+ recorded[c] = (recorded[c] || 0) + 1;
+ }
+ }
+ const data = Object.entries(recorded)
+ .sort((a, b) => b[1] - a[1])
+ .map((i) => [i[0], `${round2((i[1] * 100.0) / qParams.numRuns)}%`]);
+ const longestName = data.map((i) => i[0].length).reduce((p, c) => Math.max(p, c), 0);
+ const longestPercent = data.map((i) => i[1].length).reduce((p, c) => Math.max(p, c), 0);
+ for (const item of data) {
+ qParams.logger(`${item[0].padEnd(longestName, '.')}..${item[1].padStart(longestPercent, '.')}`);
+ }
+}
diff --git a/node_modules/fast-check/lib/check/runner/SourceValuesIterator.js b/node_modules/fast-check/lib/check/runner/SourceValuesIterator.js
new file mode 100644
index 0000000000000000000000000000000000000000..04748a0b6590b3c214f8e6795f2e3a27bd950f51
--- /dev/null
+++ b/node_modules/fast-check/lib/check/runner/SourceValuesIterator.js
@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceValuesIterator = void 0;
+class SourceValuesIterator {
+ constructor(initialValues, maxInitialIterations, remainingSkips) {
+ this.initialValues = initialValues;
+ this.maxInitialIterations = maxInitialIterations;
+ this.remainingSkips = remainingSkips;
+ }
+ [Symbol.iterator]() {
+ return this;
+ }
+ next() {
+ if (--this.maxInitialIterations !== -1 && this.remainingSkips >= 0) {
+ const n = this.initialValues.next();
+ if (!n.done)
+ return { value: n.value, done: false };
+ }
+ return { value: undefined, done: true };
+ }
+ skippedOne() {
+ --this.remainingSkips;
+ ++this.maxInitialIterations;
+ }
+}
+exports.SourceValuesIterator = SourceValuesIterator;
diff --git a/node_modules/fast-check/lib/check/runner/Tosser.js b/node_modules/fast-check/lib/check/runner/Tosser.js
new file mode 100644
index 0000000000000000000000000000000000000000..1de64078b02afc1a81133e16a642e7e1e75fbc1f
--- /dev/null
+++ b/node_modules/fast-check/lib/check/runner/Tosser.js
@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toss = toss;
+exports.lazyToss = lazyToss;
+const pure_rand_1 = require("pure-rand");
+const Random_1 = require("../../random/generator/Random");
+const Value_1 = require("../arbitrary/definition/Value");
+const globals_1 = require("../../utils/globals");
+function tossNext(generator, rng, index) {
+ rng.unsafeJump();
+ return generator.generate(new Random_1.Random(rng), index);
+}
+function* toss(generator, seed, random, examples) {
+ for (let idx = 0; idx !== examples.length; ++idx) {
+ yield new Value_1.Value(examples[idx], undefined);
+ }
+ for (let idx = 0, rng = random(seed);; ++idx) {
+ yield tossNext(generator, rng, idx);
+ }
+}
+function lazyGenerate(generator, rng, idx) {
+ return () => generator.generate(new Random_1.Random(rng), idx);
+}
+function* lazyToss(generator, seed, random, examples) {
+ yield* (0, globals_1.safeMap)(examples, (e) => () => new Value_1.Value(e, undefined));
+ let idx = 0;
+ let rng = random(seed);
+ for (;;) {
+ rng = rng.jump ? rng.jump() : (0, pure_rand_1.skipN)(rng, 42);
+ yield lazyGenerate(generator, rng, idx++);
+ }
+}
diff --git a/node_modules/fast-check/lib/check/runner/configuration/GlobalParameters.js b/node_modules/fast-check/lib/check/runner/configuration/GlobalParameters.js
new file mode 100644
index 0000000000000000000000000000000000000000..ddc45bb25dfc92061aea8460ce89c1dc7d8829fd
--- /dev/null
+++ b/node_modules/fast-check/lib/check/runner/configuration/GlobalParameters.js
@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureGlobal = configureGlobal;
+exports.readConfigureGlobal = readConfigureGlobal;
+exports.resetConfigureGlobal = resetConfigureGlobal;
+let globalParameters = {};
+function configureGlobal(parameters) {
+ globalParameters = parameters;
+}
+function readConfigureGlobal() {
+ return globalParameters;
+}
+function resetConfigureGlobal() {
+ globalParameters = {};
+}
diff --git a/node_modules/fast-check/lib/check/runner/configuration/Parameters.js b/node_modules/fast-check/lib/check/runner/configuration/Parameters.js
new file mode 100644
index 0000000000000000000000000000000000000000..c8ad2e549bdc6801e0d1c80b0308d4b9bd4985ce
--- /dev/null
+++ b/node_modules/fast-check/lib/check/runner/configuration/Parameters.js
@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
diff --git a/node_modules/fast-check/lib/check/runner/configuration/QualifiedParameters.js b/node_modules/fast-check/lib/check/runner/configuration/QualifiedParameters.js
new file mode 100644
index 0000000000000000000000000000000000000000..08fb95508c6e43b77f7f775cde805130e4a4b3cd
--- /dev/null
+++ b/node_modules/fast-check/lib/check/runner/configuration/QualifiedParameters.js
@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QualifiedParameters = void 0;
+const pure_rand_1 = require("pure-rand");
+const VerbosityLevel_1 = require("./VerbosityLevel");
+const safeDateNow = Date.now;
+const safeMathMin = Math.min;
+const safeMathRandom = Math.random;
+class QualifiedParameters {
+ constructor(op) {
+ const p = op || {};
+ this.seed = QualifiedParameters.readSeed(p);
+ this.randomType = QualifiedParameters.readRandomType(p);
+ this.numRuns = QualifiedParameters.readNumRuns(p);
+ this.verbose = QualifiedParameters.readVerbose(p);
+ this.maxSkipsPerRun = QualifiedParameters.readOrDefault(p, 'maxSkipsPerRun', 100);
+ this.timeout = QualifiedParameters.safeTimeout(QualifiedParameters.readOrDefault(p, 'timeout', null));
+ this.skipAllAfterTimeLimit = QualifiedParameters.safeTimeout(QualifiedParameters.readOrDefault(p, 'skipAllAfterTimeLimit', null));
+ this.interruptAfterTimeLimit = QualifiedParameters.safeTimeout(QualifiedParameters.readOrDefault(p, 'interruptAfterTimeLimit', null));
+ this.markInterruptAsFailure = QualifiedParameters.readBoolean(p, 'markInterruptAsFailure');
+ this.skipEqualValues = QualifiedParameters.readBoolean(p, 'skipEqualValues');
+ this.ignoreEqualValues = QualifiedParameters.readBoolean(p, 'ignoreEqualValues');
+ this.logger = QualifiedParameters.readOrDefault(p, 'logger', (v) => {
+ console.log(v);
+ });
+ this.path = QualifiedParameters.readOrDefault(p, 'path', '');
+ this.unbiased = QualifiedParameters.readBoolean(p, 'unbiased');
+ this.examples = QualifiedParameters.readOrDefault(p, 'examples', []);
+ this.endOnFailure = QualifiedParameters.readBoolean(p, 'endOnFailure');
+ this.reporter = QualifiedParameters.readOrDefault(p, 'reporter', null);
+ this.asyncReporter = QualifiedParameters.readOrDefault(p, 'asyncReporter', null);
+ this.errorWithCause = QualifiedParameters.readBoolean(p, 'errorWithCause');
+ }
+ toParameters() {
+ const orUndefined = (value) => (value !== null ? value : undefined);
+ const parameters = {
+ seed: this.seed,
+ randomType: this.randomType,
+ numRuns: this.numRuns,
+ maxSkipsPerRun: this.maxSkipsPerRun,
+ timeout: orUndefined(this.timeout),
+ skipAllAfterTimeLimit: orUndefined(this.skipAllAfterTimeLimit),
+ interruptAfterTimeLimit: orUndefined(this.interruptAfterTimeLimit),
+ markInterruptAsFailure: this.markInterruptAsFailure,
+ skipEqualValues: this.skipEqualValues,
+ ignoreEqualValues: this.ignoreEqualValues,
+ path: this.path,
+ logger: this.logger,
+ unbiased: this.unbiased,
+ verbose: this.verbose,
+ examples: this.examples,
+ endOnFailure: this.endOnFailure,
+ reporter: orUndefined(this.reporter),
+ asyncReporter: orUndefined(this.asyncReporter),
+ errorWithCause: this.errorWithCause,
+ };
+ return parameters;
+ }
+ static read(op) {
+ return new QualifiedParameters(op);
+ }
+}
+exports.QualifiedParameters = QualifiedParameters;
+QualifiedParameters.createQualifiedRandomGenerator = (random) => {
+ return (seed) => {
+ const rng = random(seed);
+ if (rng.unsafeJump === undefined) {
+ rng.unsafeJump = () => (0, pure_rand_1.unsafeSkipN)(rng, 42);
+ }
+ return rng;
+ };
+};
+QualifiedParameters.readSeed = (p) => {
+ if (p.seed == null)
+ return safeDateNow() ^ (safeMathRandom() * 0x100000000);
+ const seed32 = p.seed | 0;
+ if (p.seed === seed32)
+ return seed32;
+ const gap = p.seed - seed32;
+ return seed32 ^ (gap * 0x100000000);
+};
+QualifiedParameters.readRandomType = (p) => {
+ if (p.randomType == null)
+ return pure_rand_1.default.xorshift128plus;
+ if (typeof p.randomType === 'string') {
+ switch (p.randomType) {
+ case 'mersenne':
+ return QualifiedParameters.createQualifiedRandomGenerator(pure_rand_1.default.mersenne);
+ case 'congruential':
+ case 'congruential32':
+ return QualifiedParameters.createQualifiedRandomGenerator(pure_rand_1.default.congruential32);
+ case 'xorshift128plus':
+ return pure_rand_1.default.xorshift128plus;
+ case 'xoroshiro128plus':
+ return pure_rand_1.default.xoroshiro128plus;
+ default:
+ throw new Error(`Invalid random specified: '${p.randomType}'`);
+ }
+ }
+ const mrng = p.randomType(0);
+ if ('min' in mrng && mrng.min !== -0x80000000) {
+ throw new Error(`Invalid random number generator: min must equal -0x80000000, got ${String(mrng.min)}`);
+ }
+ if ('max' in mrng && mrng.max !== 0x7fffffff) {
+ throw new Error(`Invalid random number generator: max must equal 0x7fffffff, got ${String(mrng.max)}`);
+ }
+ if ('unsafeJump' in mrng) {
+ return p.randomType;
+ }
+ return QualifiedParameters.createQualifiedRandomGenerator(p.randomType);
+};
+QualifiedParameters.readNumRuns = (p) => {
+ const defaultValue = 100;
+ if (p.numRuns != null)
+ return p.numRuns;
+ if (p.num_runs != null)
+ return p.num_runs;
+ return defaultValue;
+};
+QualifiedParameters.readVerbose = (p) => {
+ if (p.verbose == null)
+ return VerbosityLevel_1.VerbosityLevel.None;
+ if (typeof p.verbose === 'boolean') {
+ return p.verbose === true ? VerbosityLevel_1.VerbosityLevel.Verbose : VerbosityLevel_1.VerbosityLevel.None;
+ }
+ if (p.verbose <= VerbosityLevel_1.VerbosityLevel.None) {
+ return VerbosityLevel_1.VerbosityLevel.None;
+ }
+ if (p.verbose >= VerbosityLevel_1.VerbosityLevel.VeryVerbose) {
+ return VerbosityLevel_1.VerbosityLevel.VeryVerbose;
+ }
+ return p.verbose | 0;
+};
+QualifiedParameters.readBoolean = (p, key) => p[key] === true;
+QualifiedParameters.readOrDefault = (p, key, defaultValue) => {
+ const value = p[key];
+ return value != null ? value : defaultValue;
+};
+QualifiedParameters.safeTimeout = (value) => {
+ if (value === null) {
+ return null;
+ }
+ return safeMathMin(value, 0x7fffffff);
+};
diff --git a/node_modules/fast-check/lib/check/runner/configuration/RandomType.js b/node_modules/fast-check/lib/check/runner/configuration/RandomType.js
new file mode 100644
index 0000000000000000000000000000000000000000..c8ad2e549bdc6801e0d1c80b0308d4b9bd4985ce
--- /dev/null
+++ b/node_modules/fast-check/lib/check/runner/configuration/RandomType.js
@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
diff --git a/node_modules/fast-check/lib/check/runner/configuration/VerbosityLevel.js b/node_modules/fast-check/lib/check/runner/configuration/VerbosityLevel.js
new file mode 100644
index 0000000000000000000000000000000000000000..24f63b4660b4aec9a01690401934789792a046c0
--- /dev/null
+++ b/node_modules/fast-check/lib/check/runner/configuration/VerbosityLevel.js
@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VerbosityLevel = void 0;
+var VerbosityLevel;
+(function (VerbosityLevel) {
+ VerbosityLevel[VerbosityLevel["None"] = 0] = "None";
+ VerbosityLevel[VerbosityLevel["Verbose"] = 1] = "Verbose";
+ VerbosityLevel[VerbosityLevel["VeryVerbose"] = 2] = "VeryVerbose";
+})(VerbosityLevel || (exports.VerbosityLevel = VerbosityLevel = {}));
diff --git a/node_modules/fast-check/lib/check/runner/reporter/ExecutionStatus.js b/node_modules/fast-check/lib/check/runner/reporter/ExecutionStatus.js
new file mode 100644
index 0000000000000000000000000000000000000000..a9317004c99b4e1db32579149add370637b66d7f
--- /dev/null
+++ b/node_modules/fast-check/lib/check/runner/reporter/ExecutionStatus.js
@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecutionStatus = void 0;
+var ExecutionStatus;
+(function (ExecutionStatus) {
+ ExecutionStatus[ExecutionStatus["Success"] = 0] = "Success";
+ ExecutionStatus[ExecutionStatus["Skipped"] = -1] = "Skipped";
+ ExecutionStatus[ExecutionStatus["Failure"] = 1] = "Failure";
+})(ExecutionStatus || (exports.ExecutionStatus = ExecutionStatus = {}));
diff --git a/node_modules/fast-check/lib/check/runner/reporter/ExecutionTree.js b/node_modules/fast-check/lib/check/runner/reporter/ExecutionTree.js
new file mode 100644
index 0000000000000000000000000000000000000000..c8ad2e549bdc6801e0d1c80b0308d4b9bd4985ce
--- /dev/null
+++ b/node_modules/fast-check/lib/check/runner/reporter/ExecutionTree.js
@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
diff --git a/node_modules/fast-check/lib/check/runner/reporter/RunDetails.js b/node_modules/fast-check/lib/check/runner/reporter/RunDetails.js
new file mode 100644
index 0000000000000000000000000000000000000000..c8ad2e549bdc6801e0d1c80b0308d4b9bd4985ce
--- /dev/null
+++ b/node_modules/fast-check/lib/check/runner/reporter/RunDetails.js
@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
diff --git a/node_modules/fast-check/lib/check/runner/reporter/RunExecution.js b/node_modules/fast-check/lib/check/runner/reporter/RunExecution.js
new file mode 100644
index 0000000000000000000000000000000000000000..b92706e4da639eb76b5972f222d494e55f9490d4
--- /dev/null
+++ b/node_modules/fast-check/lib/check/runner/reporter/RunExecution.js
@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunExecution = void 0;
+const VerbosityLevel_1 = require("../configuration/VerbosityLevel");
+const ExecutionStatus_1 = require("./ExecutionStatus");
+const globals_1 = require("../../../utils/globals");
+class RunExecution {
+ constructor(verbosity, interruptedAsFailure) {
+ this.verbosity = verbosity;
+ this.interruptedAsFailure = interruptedAsFailure;
+ this.isSuccess = () => this.pathToFailure == null;
+ this.firstFailure = () => (this.pathToFailure ? +(0, globals_1.safeSplit)(this.pathToFailure, ':')[0] : -1);
+ this.numShrinks = () => (this.pathToFailure ? (0, globals_1.safeSplit)(this.pathToFailure, ':').length - 1 : 0);
+ this.rootExecutionTrees = [];
+ this.currentLevelExecutionTrees = this.rootExecutionTrees;
+ this.failure = null;
+ this.numSkips = 0;
+ this.numSuccesses = 0;
+ this.interrupted = false;
+ }
+ appendExecutionTree(status, value) {
+ const currentTree = { status, value, children: [] };
+ this.currentLevelExecutionTrees.push(currentTree);
+ return currentTree;
+ }
+ fail(value, id, failure) {
+ if (this.verbosity >= VerbosityLevel_1.VerbosityLevel.Verbose) {
+ const currentTree = this.appendExecutionTree(ExecutionStatus_1.ExecutionStatus.Failure, value);
+ this.currentLevelExecutionTrees = currentTree.children;
+ }
+ if (this.pathToFailure == null)
+ this.pathToFailure = `${id}`;
+ else
+ this.pathToFailure += `:${id}`;
+ this.value = value;
+ this.failure = failure;
+ }
+ skip(value) {
+ if (this.verbosity >= VerbosityLevel_1.VerbosityLevel.VeryVerbose) {
+ this.appendExecutionTree(ExecutionStatus_1.ExecutionStatus.Skipped, value);
+ }
+ if (this.pathToFailure == null) {
+ ++this.numSkips;
+ }
+ }
+ success(value) {
+ if (this.verbosity >= VerbosityLevel_1.VerbosityLevel.VeryVerbose) {
+ this.appendExecutionTree(ExecutionStatus_1.ExecutionStatus.Success, value);
+ }
+ if (this.pathToFailure == null) {
+ ++this.numSuccesses;
+ }
+ }
+ interrupt() {
+ this.interrupted = true;
+ }
+ extractFailures() {
+ if (this.isSuccess()) {
+ return [];
+ }
+ const failures = [];
+ let cursor = this.rootExecutionTrees;
+ while (cursor.length > 0 && cursor[cursor.length - 1].status === ExecutionStatus_1.ExecutionStatus.Failure) {
+ const failureTree = cursor[cursor.length - 1];
+ failures.push(failureTree.value);
+ cursor = failureTree.children;
+ }
+ return failures;
+ }
+ toRunDetails(seed, basePath, maxSkips, qParams) {
+ if (!this.isSuccess()) {
+ return {
+ failed: true,
+ interrupted: this.interrupted,
+ numRuns: this.firstFailure() + 1 - this.numSkips,
+ numSkips: this.numSkips,
+ numShrinks: this.numShrinks(),
+ seed,
+ counterexample: this.value,
+ counterexamplePath: RunExecution.mergePaths(basePath, this.pathToFailure),
+ error: this.failure.errorMessage,
+ errorInstance: this.failure.error,
+ failures: this.extractFailures(),
+ executionSummary: this.rootExecutionTrees,
+ verbose: this.verbosity,
+ runConfiguration: qParams.toParameters(),
+ };
+ }
+ const considerInterruptedAsFailure = this.interruptedAsFailure || this.numSuccesses === 0;
+ const failed = this.numSkips > maxSkips || (this.interrupted && considerInterruptedAsFailure);
+ const out = {
+ failed,
+ interrupted: this.interrupted,
+ numRuns: this.numSuccesses,
+ numSkips: this.numSkips,
+ numShrinks: 0,
+ seed,
+ counterexample: null,
+ counterexamplePath: null,
+ error: null,
+ errorInstance: null,
+ failures: [],
+ executionSummary: this.rootExecutionTrees,
+ verbose: this.verbosity,
+ runConfiguration: qParams.toParameters(),
+ };
+ return out;
+ }
+}
+exports.RunExecution = RunExecution;
+RunExecution.mergePaths = (offsetPath, path) => {
+ if (offsetPath.length === 0)
+ return path;
+ const offsetItems = offsetPath.split(':');
+ const remainingItems = path.split(':');
+ const middle = +offsetItems[offsetItems.length - 1] + +remainingItems[0];
+ return [...offsetItems.slice(0, offsetItems.length - 1), `${middle}`, ...remainingItems.slice(1)].join(':');
+};
diff --git a/node_modules/fast-check/lib/check/runner/utils/PathWalker.js b/node_modules/fast-check/lib/check/runner/utils/PathWalker.js
new file mode 100644
index 0000000000000000000000000000000000000000..0e093ca84e7de02c8b706d2742c3ec2abdeda85b
--- /dev/null
+++ b/node_modules/fast-check/lib/check/runner/utils/PathWalker.js
@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pathWalk = pathWalk;
+function produce(producer) {
+ return producer();
+}
+function pathWalk(path, initialProducers, shrink) {
+ const producers = initialProducers;
+ const segments = path.split(':').map((text) => +text);
+ if (segments.length === 0) {
+ return producers.map(produce);
+ }
+ if (!segments.every((v) => !Number.isNaN(v))) {
+ throw new Error(`Unable to replay, got invalid path=${path}`);
+ }
+ let values = producers.drop(segments[0]).map(produce);
+ for (const s of segments.slice(1)) {
+ const valueToShrink = values.getNthOrLast(0);
+ if (valueToShrink === null) {
+ throw new Error(`Unable to replay, got wrong path=${path}`);
+ }
+ values = shrink(valueToShrink).drop(s);
+ }
+ return values;
+}
diff --git a/node_modules/fast-check/lib/check/runner/utils/RunDetailsFormatter.js b/node_modules/fast-check/lib/check/runner/utils/RunDetailsFormatter.js
new file mode 100644
index 0000000000000000000000000000000000000000..6279e7e5d4afe42195d96f28a5e1931f3713f185
--- /dev/null
+++ b/node_modules/fast-check/lib/check/runner/utils/RunDetailsFormatter.js
@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reportRunDetails = reportRunDetails;
+exports.asyncReportRunDetails = asyncReportRunDetails;
+exports.defaultReportMessage = defaultReportMessage;
+exports.asyncDefaultReportMessage = asyncDefaultReportMessage;
+const globals_1 = require("../../../utils/globals");
+const stringify_1 = require("../../../utils/stringify");
+const VerbosityLevel_1 = require("../configuration/VerbosityLevel");
+const ExecutionStatus_1 = require("../reporter/ExecutionStatus");
+const safeObjectAssign = Object.assign;
+function formatHints(hints) {
+ if (hints.length === 1) {
+ return `Hint: ${hints[0]}`;
+ }
+ return hints.map((h, idx) => `Hint (${idx + 1}): ${h}`).join('\n');
+}
+function formatFailures(failures, stringifyOne) {
+ return `Encountered failures were:\n- ${failures.map(stringifyOne).join('\n- ')}`;
+}
+function formatExecutionSummary(executionTrees, stringifyOne) {
+ const summaryLines = [];
+ const remainingTreesAndDepth = [];
+ for (const tree of executionTrees.slice().reverse()) {
+ remainingTreesAndDepth.push({ depth: 1, tree });
+ }
+ while (remainingTreesAndDepth.length !== 0) {
+ const currentTreeAndDepth = remainingTreesAndDepth.pop();
+ const currentTree = currentTreeAndDepth.tree;
+ const currentDepth = currentTreeAndDepth.depth;
+ const statusIcon = currentTree.status === ExecutionStatus_1.ExecutionStatus.Success
+ ? '\x1b[32m\u221A\x1b[0m'
+ : currentTree.status === ExecutionStatus_1.ExecutionStatus.Failure
+ ? '\x1b[31m\xD7\x1b[0m'
+ : '\x1b[33m!\x1b[0m';
+ const leftPadding = Array(currentDepth).join('. ');
+ summaryLines.push(`${leftPadding}${statusIcon} ${stringifyOne(currentTree.value)}`);
+ for (const tree of currentTree.children.slice().reverse()) {
+ remainingTreesAndDepth.push({ depth: currentDepth + 1, tree });
+ }
+ }
+ return `Execution summary:\n${summaryLines.join('\n')}`;
+}
+function preFormatTooManySkipped(out, stringifyOne) {
+ const message = `Failed to run property, too many pre-condition failures encountered\n{ seed: ${out.seed} }\n\nRan ${out.numRuns} time(s)\nSkipped ${out.numSkips} time(s)`;
+ let details = null;
+ const hints = [
+ 'Try to reduce the number of rejected values by combining map, flatMap and built-in arbitraries',
+ 'Increase failure tolerance by setting maxSkipsPerRun to an higher value',
+ ];
+ if (out.verbose >= VerbosityLevel_1.VerbosityLevel.VeryVerbose) {
+ details = formatExecutionSummary(out.executionSummary, stringifyOne);
+ }
+ else {
+ (0, globals_1.safePush)(hints, 'Enable verbose mode at level VeryVerbose in order to check all generated values and their associated status');
+ }
+ return { message, details, hints };
+}
+function preFormatFailure(out, stringifyOne) {
+ const noErrorInMessage = out.runConfiguration.errorWithCause;
+ const messageErrorPart = noErrorInMessage ? '' : `\nGot ${(0, globals_1.safeReplace)(out.error, /^Error: /, 'error: ')}`;
+ const message = `Property failed after ${out.numRuns} tests\n{ seed: ${out.seed}, path: "${out.counterexamplePath}", endOnFailure: true }\nCounterexample: ${stringifyOne(out.counterexample)}\nShrunk ${out.numShrinks} time(s)${messageErrorPart}`;
+ let details = null;
+ const hints = [];
+ if (out.verbose >= VerbosityLevel_1.VerbosityLevel.VeryVerbose) {
+ details = formatExecutionSummary(out.executionSummary, stringifyOne);
+ }
+ else if (out.verbose === VerbosityLevel_1.VerbosityLevel.Verbose) {
+ details = formatFailures(out.failures, stringifyOne);
+ }
+ else {
+ (0, globals_1.safePush)(hints, 'Enable verbose mode in order to have the list of all failing values encountered during the run');
+ }
+ return { message, details, hints };
+}
+function preFormatEarlyInterrupted(out, stringifyOne) {
+ const message = `Property interrupted after ${out.numRuns} tests\n{ seed: ${out.seed} }`;
+ let details = null;
+ const hints = [];
+ if (out.verbose >= VerbosityLevel_1.VerbosityLevel.VeryVerbose) {
+ details = formatExecutionSummary(out.executionSummary, stringifyOne);
+ }
+ else {
+ (0, globals_1.safePush)(hints, 'Enable verbose mode at level VeryVerbose in order to check all generated values and their associated status');
+ }
+ return { message, details, hints };
+}
+function defaultReportMessageInternal(out, stringifyOne) {
+ if (!out.failed)
+ return;
+ const { message, details, hints } = out.counterexamplePath === null
+ ? out.interrupted
+ ? preFormatEarlyInterrupted(out, stringifyOne)
+ : preFormatTooManySkipped(out, stringifyOne)
+ : preFormatFailure(out, stringifyOne);
+ let errorMessage = message;
+ if (details != null)
+ errorMessage += `\n\n${details}`;
+ if (hints.length > 0)
+ errorMessage += `\n\n${formatHints(hints)}`;
+ return errorMessage;
+}
+function defaultReportMessage(out) {
+ return defaultReportMessageInternal(out, stringify_1.stringify);
+}
+async function asyncDefaultReportMessage(out) {
+ const pendingStringifieds = [];
+ function stringifyOne(value) {
+ const stringified = (0, stringify_1.possiblyAsyncStringify)(value);
+ if (typeof stringified === 'string') {
+ return stringified;
+ }
+ pendingStringifieds.push(Promise.all([value, stringified]));
+ return '\u2026';
+ }
+ const firstTryMessage = defaultReportMessageInternal(out, stringifyOne);
+ if (pendingStringifieds.length === 0) {
+ return firstTryMessage;
+ }
+ const registeredValues = new globals_1.Map(await Promise.all(pendingStringifieds));
+ function stringifySecond(value) {
+ const asyncStringifiedIfRegistered = (0, globals_1.safeMapGet)(registeredValues, value);
+ if (asyncStringifiedIfRegistered !== undefined) {
+ return asyncStringifiedIfRegistered;
+ }
+ return (0, stringify_1.stringify)(value);
+ }
+ return defaultReportMessageInternal(out, stringifySecond);
+}
+function buildError(errorMessage, out) {
+ if (!out.runConfiguration.errorWithCause) {
+ throw new globals_1.Error(errorMessage);
+ }
+ const ErrorWithCause = globals_1.Error;
+ const error = new ErrorWithCause(errorMessage, { cause: out.errorInstance });
+ if (!('cause' in error)) {
+ safeObjectAssign(error, { cause: out.errorInstance });
+ }
+ return error;
+}
+function throwIfFailed(out) {
+ if (!out.failed)
+ return;
+ throw buildError(defaultReportMessage(out), out);
+}
+async function asyncThrowIfFailed(out) {
+ if (!out.failed)
+ return;
+ throw buildError(await asyncDefaultReportMessage(out), out);
+}
+function reportRunDetails(out) {
+ if (out.runConfiguration.asyncReporter)
+ return out.runConfiguration.asyncReporter(out);
+ else if (out.runConfiguration.reporter)
+ return out.runConfiguration.reporter(out);
+ else
+ return throwIfFailed(out);
+}
+async function asyncReportRunDetails(out) {
+ if (out.runConfiguration.asyncReporter)
+ return out.runConfiguration.asyncReporter(out);
+ else if (out.runConfiguration.reporter)
+ return out.runConfiguration.reporter(out);
+ else
+ return asyncThrowIfFailed(out);
+}
diff --git a/node_modules/fast-check/lib/check/symbols.js b/node_modules/fast-check/lib/check/symbols.js
new file mode 100644
index 0000000000000000000000000000000000000000..866c417531c8a7238da6d10d540929866761b252
--- /dev/null
+++ b/node_modules/fast-check/lib/check/symbols.js
@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cloneMethod = void 0;
+exports.hasCloneMethod = hasCloneMethod;
+exports.cloneIfNeeded = cloneIfNeeded;
+exports.cloneMethod = Symbol.for('fast-check/cloneMethod');
+function hasCloneMethod(instance) {
+ return (instance !== null &&
+ (typeof instance === 'object' || typeof instance === 'function') &&
+ exports.cloneMethod in instance &&
+ typeof instance[exports.cloneMethod] === 'function');
+}
+function cloneIfNeeded(instance) {
+ return hasCloneMethod(instance) ? instance[exports.cloneMethod]() : instance;
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/AdapterArbitrary.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/AdapterArbitrary.js
new file mode 100644
index 0000000000000000000000000000000000000000..97707e9a7792bccb2cbd5b0b469e0fc5ebdf9f61
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/AdapterArbitrary.js
@@ -0,0 +1,38 @@
+import { Arbitrary } from '../../check/arbitrary/definition/Arbitrary.js';
+import { Value } from '../../check/arbitrary/definition/Value.js';
+import { Stream } from '../../stream/Stream.js';
+const AdaptedValue = Symbol('adapted-value');
+function toAdapterValue(rawValue, adapter) {
+ const adapted = adapter(rawValue.value_);
+ if (!adapted.adapted) {
+ return rawValue;
+ }
+ return new Value(adapted.value, AdaptedValue);
+}
+class AdapterArbitrary extends Arbitrary {
+ constructor(sourceArb, adapter) {
+ super();
+ this.sourceArb = sourceArb;
+ this.adapter = adapter;
+ this.adaptValue = (rawValue) => toAdapterValue(rawValue, adapter);
+ }
+ generate(mrng, biasFactor) {
+ const rawValue = this.sourceArb.generate(mrng, biasFactor);
+ return this.adaptValue(rawValue);
+ }
+ canShrinkWithoutContext(value) {
+ return this.sourceArb.canShrinkWithoutContext(value) && !this.adapter(value).adapted;
+ }
+ shrink(value, context) {
+ if (context === AdaptedValue) {
+ if (!this.sourceArb.canShrinkWithoutContext(value)) {
+ return Stream.nil();
+ }
+ return this.sourceArb.shrink(value, undefined).map(this.adaptValue);
+ }
+ return this.sourceArb.shrink(value, context).map(this.adaptValue);
+ }
+}
+export function adapter(sourceArb, adapter) {
+ return new AdapterArbitrary(sourceArb, adapter);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/AlwaysShrinkableArbitrary.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/AlwaysShrinkableArbitrary.js
new file mode 100644
index 0000000000000000000000000000000000000000..024183cb39a758bff26e991613f0e74ab37567b4
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/AlwaysShrinkableArbitrary.js
@@ -0,0 +1,23 @@
+import { Arbitrary } from '../../check/arbitrary/definition/Arbitrary.js';
+import { Stream } from '../../stream/Stream.js';
+import { noUndefinedAsContext, UndefinedContextPlaceholder } from './helpers/NoUndefinedAsContext.js';
+export class AlwaysShrinkableArbitrary extends Arbitrary {
+ constructor(arb) {
+ super();
+ this.arb = arb;
+ }
+ generate(mrng, biasFactor) {
+ const value = this.arb.generate(mrng, biasFactor);
+ return noUndefinedAsContext(value);
+ }
+ canShrinkWithoutContext(value) {
+ return true;
+ }
+ shrink(value, context) {
+ if (context === undefined && !this.arb.canShrinkWithoutContext(value)) {
+ return Stream.nil();
+ }
+ const safeContext = context !== UndefinedContextPlaceholder ? context : undefined;
+ return this.arb.shrink(value, safeContext).map(noUndefinedAsContext);
+ }
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/ArrayArbitrary.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/ArrayArbitrary.js
new file mode 100644
index 0000000000000000000000000000000000000000..5cfb59215f291a9fe7b36e307678c027c7b7fe65
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/ArrayArbitrary.js
@@ -0,0 +1,219 @@
+import { Stream } from '../../stream/Stream.js';
+import { cloneIfNeeded, cloneMethod } from '../../check/symbols.js';
+import { integer } from '../integer.js';
+import { makeLazy } from '../../stream/LazyIterableIterator.js';
+import { Arbitrary } from '../../check/arbitrary/definition/Arbitrary.js';
+import { Value } from '../../check/arbitrary/definition/Value.js';
+import { getDepthContextFor } from './helpers/DepthContext.js';
+import { buildSlicedGenerator } from './helpers/BuildSlicedGenerator.js';
+import { safeMap, safePush, safeSlice } from '../../utils/globals.js';
+const safeMathFloor = Math.floor;
+const safeMathLog = Math.log;
+const safeMathMax = Math.max;
+const safeArrayIsArray = Array.isArray;
+function biasedMaxLength(minLength, maxLength) {
+ if (minLength === maxLength) {
+ return minLength;
+ }
+ return minLength + safeMathFloor(safeMathLog(maxLength - minLength) / safeMathLog(2));
+}
+export class ArrayArbitrary extends Arbitrary {
+ constructor(arb, minLength, maxGeneratedLength, maxLength, depthIdentifier, setBuilder, customSlices) {
+ super();
+ this.arb = arb;
+ this.minLength = minLength;
+ this.maxGeneratedLength = maxGeneratedLength;
+ this.maxLength = maxLength;
+ this.setBuilder = setBuilder;
+ this.customSlices = customSlices;
+ this.lengthArb = integer({ min: minLength, max: maxGeneratedLength });
+ this.depthContext = getDepthContextFor(depthIdentifier);
+ }
+ preFilter(tab) {
+ if (this.setBuilder === undefined) {
+ return tab;
+ }
+ const s = this.setBuilder();
+ for (let index = 0; index !== tab.length; ++index) {
+ s.tryAdd(tab[index]);
+ }
+ return s.getData();
+ }
+ static makeItCloneable(vs, shrinkables) {
+ vs[cloneMethod] = () => {
+ const cloned = [];
+ for (let idx = 0; idx !== shrinkables.length; ++idx) {
+ safePush(cloned, shrinkables[idx].value);
+ }
+ this.makeItCloneable(cloned, shrinkables);
+ return cloned;
+ };
+ return vs;
+ }
+ generateNItemsNoDuplicates(setBuilder, N, mrng, biasFactorItems) {
+ let numSkippedInRow = 0;
+ const s = setBuilder();
+ const slicedGenerator = buildSlicedGenerator(this.arb, mrng, this.customSlices, biasFactorItems);
+ while (s.size() < N && numSkippedInRow < this.maxGeneratedLength) {
+ const current = slicedGenerator.next();
+ if (s.tryAdd(current)) {
+ numSkippedInRow = 0;
+ }
+ else {
+ numSkippedInRow += 1;
+ }
+ }
+ return s.getData();
+ }
+ safeGenerateNItemsNoDuplicates(setBuilder, N, mrng, biasFactorItems) {
+ const depthImpact = safeMathMax(0, N - biasedMaxLength(this.minLength, this.maxGeneratedLength));
+ this.depthContext.depth += depthImpact;
+ try {
+ return this.generateNItemsNoDuplicates(setBuilder, N, mrng, biasFactorItems);
+ }
+ finally {
+ this.depthContext.depth -= depthImpact;
+ }
+ }
+ generateNItems(N, mrng, biasFactorItems) {
+ const items = [];
+ const slicedGenerator = buildSlicedGenerator(this.arb, mrng, this.customSlices, biasFactorItems);
+ slicedGenerator.attemptExact(N);
+ for (let index = 0; index !== N; ++index) {
+ const current = slicedGenerator.next();
+ safePush(items, current);
+ }
+ return items;
+ }
+ safeGenerateNItems(N, mrng, biasFactorItems) {
+ const depthImpact = safeMathMax(0, N - biasedMaxLength(this.minLength, this.maxGeneratedLength));
+ this.depthContext.depth += depthImpact;
+ try {
+ return this.generateNItems(N, mrng, biasFactorItems);
+ }
+ finally {
+ this.depthContext.depth -= depthImpact;
+ }
+ }
+ wrapper(itemsRaw, shrunkOnce, itemsRawLengthContext, startIndex) {
+ const items = shrunkOnce ? this.preFilter(itemsRaw) : itemsRaw;
+ let cloneable = false;
+ const vs = [];
+ const itemsContexts = [];
+ for (let idx = 0; idx !== items.length; ++idx) {
+ const s = items[idx];
+ cloneable = cloneable || s.hasToBeCloned;
+ safePush(vs, s.value);
+ safePush(itemsContexts, s.context);
+ }
+ if (cloneable) {
+ ArrayArbitrary.makeItCloneable(vs, items);
+ }
+ const context = {
+ shrunkOnce,
+ lengthContext: itemsRaw.length === items.length && itemsRawLengthContext !== undefined
+ ? itemsRawLengthContext
+ : undefined,
+ itemsContexts,
+ startIndex,
+ };
+ return new Value(vs, context);
+ }
+ generate(mrng, biasFactor) {
+ const biasMeta = this.applyBias(mrng, biasFactor);
+ const targetSize = biasMeta.size;
+ const items = this.setBuilder !== undefined
+ ? this.safeGenerateNItemsNoDuplicates(this.setBuilder, targetSize, mrng, biasMeta.biasFactorItems)
+ : this.safeGenerateNItems(targetSize, mrng, biasMeta.biasFactorItems);
+ return this.wrapper(items, false, undefined, 0);
+ }
+ applyBias(mrng, biasFactor) {
+ if (biasFactor === undefined) {
+ return { size: this.lengthArb.generate(mrng, undefined).value };
+ }
+ if (this.minLength === this.maxGeneratedLength) {
+ return { size: this.lengthArb.generate(mrng, undefined).value, biasFactorItems: biasFactor };
+ }
+ if (mrng.nextInt(1, biasFactor) !== 1) {
+ return { size: this.lengthArb.generate(mrng, undefined).value };
+ }
+ if (mrng.nextInt(1, biasFactor) !== 1 || this.minLength === this.maxGeneratedLength) {
+ return { size: this.lengthArb.generate(mrng, undefined).value, biasFactorItems: biasFactor };
+ }
+ const maxBiasedLength = biasedMaxLength(this.minLength, this.maxGeneratedLength);
+ const targetSizeValue = integer({ min: this.minLength, max: maxBiasedLength }).generate(mrng, undefined);
+ return { size: targetSizeValue.value, biasFactorItems: biasFactor };
+ }
+ canShrinkWithoutContext(value) {
+ if (!safeArrayIsArray(value) || this.minLength > value.length || value.length > this.maxLength) {
+ return false;
+ }
+ for (let index = 0; index !== value.length; ++index) {
+ if (!(index in value)) {
+ return false;
+ }
+ if (!this.arb.canShrinkWithoutContext(value[index])) {
+ return false;
+ }
+ }
+ const filtered = this.preFilter(safeMap(value, (item) => new Value(item, undefined)));
+ return filtered.length === value.length;
+ }
+ shrinkItemByItem(value, safeContext, endIndex) {
+ const shrinks = [];
+ for (let index = safeContext.startIndex; index < endIndex; ++index) {
+ safePush(shrinks, makeLazy(() => this.arb.shrink(value[index], safeContext.itemsContexts[index]).map((v) => {
+ const beforeCurrent = safeMap(safeSlice(value, 0, index), (v, i) => new Value(cloneIfNeeded(v), safeContext.itemsContexts[i]));
+ const afterCurrent = safeMap(safeSlice(value, index + 1), (v, i) => new Value(cloneIfNeeded(v), safeContext.itemsContexts[i + index + 1]));
+ return [
+ [...beforeCurrent, v, ...afterCurrent],
+ undefined,
+ index,
+ ];
+ })));
+ }
+ return Stream.nil().join(...shrinks);
+ }
+ shrinkImpl(value, context) {
+ if (value.length === 0) {
+ return Stream.nil();
+ }
+ const safeContext = context !== undefined
+ ? context
+ : { shrunkOnce: false, lengthContext: undefined, itemsContexts: [], startIndex: 0 };
+ return (this.lengthArb
+ .shrink(value.length, safeContext.lengthContext)
+ .drop(safeContext.shrunkOnce && safeContext.lengthContext === undefined && value.length > this.minLength + 1
+ ? 1
+ : 0)
+ .map((lengthValue) => {
+ const sliceStart = value.length - lengthValue.value;
+ return [
+ safeMap(safeSlice(value, sliceStart), (v, index) => new Value(cloneIfNeeded(v), safeContext.itemsContexts[index + sliceStart])),
+ lengthValue.context,
+ 0,
+ ];
+ })
+ .join(makeLazy(() => value.length > this.minLength
+ ? this.shrinkItemByItem(value, safeContext, 1)
+ : this.shrinkItemByItem(value, safeContext, value.length)))
+ .join(value.length > this.minLength
+ ? makeLazy(() => {
+ const subContext = {
+ shrunkOnce: false,
+ lengthContext: undefined,
+ itemsContexts: safeSlice(safeContext.itemsContexts, 1),
+ startIndex: 0,
+ };
+ return this.shrinkImpl(safeSlice(value, 1), subContext)
+ .filter((v) => this.minLength <= v[0].length + 1)
+ .map((v) => {
+ return [[new Value(cloneIfNeeded(value[0]), safeContext.itemsContexts[0]), ...v[0]], undefined, 0];
+ });
+ })
+ : Stream.nil()));
+ }
+ shrink(value, context) {
+ return this.shrinkImpl(value, context).map((contextualValue) => this.wrapper(contextualValue[0], true, contextualValue[1], contextualValue[2]));
+ }
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/ArrayInt64Arbitrary.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/ArrayInt64Arbitrary.js
new file mode 100644
index 0000000000000000000000000000000000000000..8ee33e8e73671ab862eacb3e5a4d445bd4f782ef
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/ArrayInt64Arbitrary.js
@@ -0,0 +1,124 @@
+import { stream, Stream } from '../../stream/Stream.js';
+import { Arbitrary } from '../../check/arbitrary/definition/Arbitrary.js';
+import { Value } from '../../check/arbitrary/definition/Value.js';
+import { add64, halve64, isEqual64, isStrictlyNegative64, isStrictlyPositive64, isStrictlySmaller64, isZero64, logLike64, substract64, Unit64, Zero64, } from './helpers/ArrayInt64.js';
+class ArrayInt64Arbitrary extends Arbitrary {
+ constructor(min, max) {
+ super();
+ this.min = min;
+ this.max = max;
+ this.biasedRanges = null;
+ }
+ generate(mrng, biasFactor) {
+ const range = this.computeGenerateRange(mrng, biasFactor);
+ const uncheckedValue = mrng.nextArrayInt(range.min, range.max);
+ if (uncheckedValue.data.length === 1) {
+ uncheckedValue.data.unshift(0);
+ }
+ return new Value(uncheckedValue, undefined);
+ }
+ computeGenerateRange(mrng, biasFactor) {
+ if (biasFactor === undefined || mrng.nextInt(1, biasFactor) !== 1) {
+ return { min: this.min, max: this.max };
+ }
+ const ranges = this.retrieveBiasedRanges();
+ if (ranges.length === 1) {
+ return ranges[0];
+ }
+ const id = mrng.nextInt(-2 * (ranges.length - 1), ranges.length - 2);
+ return id < 0 ? ranges[0] : ranges[id + 1];
+ }
+ canShrinkWithoutContext(value) {
+ const unsafeValue = value;
+ return (typeof value === 'object' &&
+ value !== null &&
+ (unsafeValue.sign === -1 || unsafeValue.sign === 1) &&
+ Array.isArray(unsafeValue.data) &&
+ unsafeValue.data.length === 2 &&
+ ((isStrictlySmaller64(this.min, unsafeValue) && isStrictlySmaller64(unsafeValue, this.max)) ||
+ isEqual64(this.min, unsafeValue) ||
+ isEqual64(this.max, unsafeValue)));
+ }
+ shrinkArrayInt64(value, target, tryTargetAsap) {
+ const realGap = substract64(value, target);
+ function* shrinkGen() {
+ let previous = tryTargetAsap ? undefined : target;
+ const gap = tryTargetAsap ? realGap : halve64(realGap);
+ for (let toremove = gap; !isZero64(toremove); toremove = halve64(toremove)) {
+ const next = substract64(value, toremove);
+ yield new Value(next, previous);
+ previous = next;
+ }
+ }
+ return stream(shrinkGen());
+ }
+ shrink(current, context) {
+ if (!ArrayInt64Arbitrary.isValidContext(current, context)) {
+ const target = this.defaultTarget();
+ return this.shrinkArrayInt64(current, target, true);
+ }
+ if (this.isLastChanceTry(current, context)) {
+ return Stream.of(new Value(context, undefined));
+ }
+ return this.shrinkArrayInt64(current, context, false);
+ }
+ defaultTarget() {
+ if (!isStrictlyPositive64(this.min) && !isStrictlyNegative64(this.max)) {
+ return Zero64;
+ }
+ return isStrictlyNegative64(this.min) ? this.max : this.min;
+ }
+ isLastChanceTry(current, context) {
+ if (isZero64(current)) {
+ return false;
+ }
+ if (current.sign === 1) {
+ return isEqual64(current, add64(context, Unit64)) && isStrictlyPositive64(substract64(current, this.min));
+ }
+ else {
+ return isEqual64(current, substract64(context, Unit64)) && isStrictlyNegative64(substract64(current, this.max));
+ }
+ }
+ static isValidContext(_current, context) {
+ if (context === undefined) {
+ return false;
+ }
+ if (typeof context !== 'object' || context === null || !('sign' in context) || !('data' in context)) {
+ throw new Error(`Invalid context type passed to ArrayInt64Arbitrary (#1)`);
+ }
+ return true;
+ }
+ retrieveBiasedRanges() {
+ if (this.biasedRanges != null) {
+ return this.biasedRanges;
+ }
+ if (isEqual64(this.min, this.max)) {
+ this.biasedRanges = [{ min: this.min, max: this.max }];
+ return this.biasedRanges;
+ }
+ const minStrictlySmallerZero = isStrictlyNegative64(this.min);
+ const maxStrictlyGreaterZero = isStrictlyPositive64(this.max);
+ if (minStrictlySmallerZero && maxStrictlyGreaterZero) {
+ const logMin = logLike64(this.min);
+ const logMax = logLike64(this.max);
+ this.biasedRanges = [
+ { min: logMin, max: logMax },
+ { min: substract64(this.max, logMax), max: this.max },
+ { min: this.min, max: substract64(this.min, logMin) },
+ ];
+ }
+ else {
+ const logGap = logLike64(substract64(this.max, this.min));
+ const arbCloseToMin = { min: this.min, max: add64(this.min, logGap) };
+ const arbCloseToMax = { min: substract64(this.max, logGap), max: this.max };
+ this.biasedRanges = minStrictlySmallerZero
+ ? [arbCloseToMax, arbCloseToMin]
+ : [arbCloseToMin, arbCloseToMax];
+ }
+ return this.biasedRanges;
+ }
+}
+export function arrayInt64(min, max) {
+ const arb = new ArrayInt64Arbitrary(min, max);
+ return arb;
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/BigIntArbitrary.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/BigIntArbitrary.js
new file mode 100644
index 0000000000000000000000000000000000000000..bf6195f74a9dd1fe94afc86db7542a694b1adfb8
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/BigIntArbitrary.js
@@ -0,0 +1,67 @@
+import { Stream } from '../../stream/Stream.js';
+import { Arbitrary } from '../../check/arbitrary/definition/Arbitrary.js';
+import { Value } from '../../check/arbitrary/definition/Value.js';
+import { biasNumericRange, bigIntLogLike } from './helpers/BiasNumericRange.js';
+import { shrinkBigInt } from './helpers/ShrinkBigInt.js';
+import { BigInt } from '../../utils/globals.js';
+export class BigIntArbitrary extends Arbitrary {
+ constructor(min, max) {
+ super();
+ this.min = min;
+ this.max = max;
+ }
+ generate(mrng, biasFactor) {
+ const range = this.computeGenerateRange(mrng, biasFactor);
+ return new Value(mrng.nextBigInt(range.min, range.max), undefined);
+ }
+ computeGenerateRange(mrng, biasFactor) {
+ if (biasFactor === undefined || mrng.nextInt(1, biasFactor) !== 1) {
+ return { min: this.min, max: this.max };
+ }
+ const ranges = biasNumericRange(this.min, this.max, bigIntLogLike);
+ if (ranges.length === 1) {
+ return ranges[0];
+ }
+ const id = mrng.nextInt(-2 * (ranges.length - 1), ranges.length - 2);
+ return id < 0 ? ranges[0] : ranges[id + 1];
+ }
+ canShrinkWithoutContext(value) {
+ return typeof value === 'bigint' && this.min <= value && value <= this.max;
+ }
+ shrink(current, context) {
+ if (!BigIntArbitrary.isValidContext(current, context)) {
+ const target = this.defaultTarget();
+ return shrinkBigInt(current, target, true);
+ }
+ if (this.isLastChanceTry(current, context)) {
+ return Stream.of(new Value(context, undefined));
+ }
+ return shrinkBigInt(current, context, false);
+ }
+ defaultTarget() {
+ if (this.min <= 0 && this.max >= 0) {
+ return BigInt(0);
+ }
+ return this.min < 0 ? this.max : this.min;
+ }
+ isLastChanceTry(current, context) {
+ if (current > 0)
+ return current === context + BigInt(1) && current > this.min;
+ if (current < 0)
+ return current === context - BigInt(1) && current < this.max;
+ return false;
+ }
+ static isValidContext(current, context) {
+ if (context === undefined) {
+ return false;
+ }
+ if (typeof context !== 'bigint') {
+ throw new Error(`Invalid context type passed to BigIntArbitrary (#1)`);
+ }
+ const differentSigns = (current > 0 && context < 0) || (current < 0 && context > 0);
+ if (context !== BigInt(0) && differentSigns) {
+ throw new Error(`Invalid context value passed to BigIntArbitrary (#2)`);
+ }
+ return true;
+ }
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/CloneArbitrary.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/CloneArbitrary.js
new file mode 100644
index 0000000000000000000000000000000000000000..39a05c61a698ee3af9e78a47d6756067b0b6be9d
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/CloneArbitrary.js
@@ -0,0 +1,80 @@
+import { Arbitrary } from '../../check/arbitrary/definition/Arbitrary.js';
+import { Value } from '../../check/arbitrary/definition/Value.js';
+import { cloneMethod } from '../../check/symbols.js';
+import { Stream } from '../../stream/Stream.js';
+import { safeMap, safePush } from '../../utils/globals.js';
+const safeSymbolIterator = Symbol.iterator;
+const safeIsArray = Array.isArray;
+const safeObjectIs = Object.is;
+export class CloneArbitrary extends Arbitrary {
+ constructor(arb, numValues) {
+ super();
+ this.arb = arb;
+ this.numValues = numValues;
+ }
+ generate(mrng, biasFactor) {
+ const items = [];
+ if (this.numValues <= 0) {
+ return this.wrapper(items);
+ }
+ for (let idx = 0; idx !== this.numValues - 1; ++idx) {
+ safePush(items, this.arb.generate(mrng.clone(), biasFactor));
+ }
+ safePush(items, this.arb.generate(mrng, biasFactor));
+ return this.wrapper(items);
+ }
+ canShrinkWithoutContext(value) {
+ if (!safeIsArray(value) || value.length !== this.numValues) {
+ return false;
+ }
+ if (value.length === 0) {
+ return true;
+ }
+ for (let index = 1; index < value.length; ++index) {
+ if (!safeObjectIs(value[0], value[index])) {
+ return false;
+ }
+ }
+ return this.arb.canShrinkWithoutContext(value[0]);
+ }
+ shrink(value, context) {
+ if (value.length === 0) {
+ return Stream.nil();
+ }
+ return new Stream(this.shrinkImpl(value, context !== undefined ? context : [])).map((v) => this.wrapper(v));
+ }
+ *shrinkImpl(value, contexts) {
+ const its = safeMap(value, (v, idx) => this.arb.shrink(v, contexts[idx])[safeSymbolIterator]());
+ let cur = safeMap(its, (it) => it.next());
+ while (!cur[0].done) {
+ yield safeMap(cur, (c) => c.value);
+ cur = safeMap(its, (it) => it.next());
+ }
+ }
+ static makeItCloneable(vs, shrinkables) {
+ vs[cloneMethod] = () => {
+ const cloned = [];
+ for (let idx = 0; idx !== shrinkables.length; ++idx) {
+ safePush(cloned, shrinkables[idx].value);
+ }
+ this.makeItCloneable(cloned, shrinkables);
+ return cloned;
+ };
+ return vs;
+ }
+ wrapper(items) {
+ let cloneable = false;
+ const vs = [];
+ const contexts = [];
+ for (let idx = 0; idx !== items.length; ++idx) {
+ const s = items[idx];
+ cloneable = cloneable || s.hasToBeCloned;
+ safePush(vs, s.value);
+ safePush(contexts, s.context);
+ }
+ if (cloneable) {
+ CloneArbitrary.makeItCloneable(vs, items);
+ }
+ return new Value(vs, contexts);
+ }
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/CommandsArbitrary.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/CommandsArbitrary.js
new file mode 100644
index 0000000000000000000000000000000000000000..089b6f11b9f4fabeca0e325cdda5b1bb1a097366
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/CommandsArbitrary.js
@@ -0,0 +1,106 @@
+import { Arbitrary } from '../../check/arbitrary/definition/Arbitrary.js';
+import { Value } from '../../check/arbitrary/definition/Value.js';
+import { CommandsIterable } from '../../check/model/commands/CommandsIterable.js';
+import { CommandWrapper } from '../../check/model/commands/CommandWrapper.js';
+import { ReplayPath } from '../../check/model/ReplayPath.js';
+import { makeLazy } from '../../stream/LazyIterableIterator.js';
+import { Stream } from '../../stream/Stream.js';
+import { oneof } from '../oneof.js';
+import { restrictedIntegerArbitraryBuilder } from './builders/RestrictedIntegerArbitraryBuilder.js';
+export class CommandsArbitrary extends Arbitrary {
+ constructor(commandArbs, maxGeneratedCommands, maxCommands, sourceReplayPath, disableReplayLog) {
+ super();
+ this.sourceReplayPath = sourceReplayPath;
+ this.disableReplayLog = disableReplayLog;
+ this.oneCommandArb = oneof(...commandArbs).map((c) => new CommandWrapper(c));
+ this.lengthArb = restrictedIntegerArbitraryBuilder(0, maxGeneratedCommands, maxCommands);
+ this.replayPath = [];
+ this.replayPathPosition = 0;
+ }
+ metadataForReplay() {
+ return this.disableReplayLog ? '' : `replayPath=${JSON.stringify(ReplayPath.stringify(this.replayPath))}`;
+ }
+ buildValueFor(items, shrunkOnce) {
+ const commands = items.map((item) => item.value_);
+ const context = { shrunkOnce, items };
+ return new Value(new CommandsIterable(commands, () => this.metadataForReplay()), context);
+ }
+ generate(mrng) {
+ const size = this.lengthArb.generate(mrng, undefined);
+ const sizeValue = size.value;
+ const items = Array(sizeValue);
+ for (let idx = 0; idx !== sizeValue; ++idx) {
+ const item = this.oneCommandArb.generate(mrng, undefined);
+ items[idx] = item;
+ }
+ this.replayPathPosition = 0;
+ return this.buildValueFor(items, false);
+ }
+ canShrinkWithoutContext(value) {
+ return false;
+ }
+ filterOnExecution(itemsRaw) {
+ const items = [];
+ for (const c of itemsRaw) {
+ if (c.value_.hasRan) {
+ this.replayPath.push(true);
+ items.push(c);
+ }
+ else
+ this.replayPath.push(false);
+ }
+ return items;
+ }
+ filterOnReplay(itemsRaw) {
+ return itemsRaw.filter((c, idx) => {
+ const state = this.replayPath[this.replayPathPosition + idx];
+ if (state === undefined)
+ throw new Error(`Too short replayPath`);
+ if (!state && c.value_.hasRan)
+ throw new Error(`Mismatch between replayPath and real execution`);
+ return state;
+ });
+ }
+ filterForShrinkImpl(itemsRaw) {
+ if (this.replayPathPosition === 0) {
+ this.replayPath = this.sourceReplayPath !== null ? ReplayPath.parse(this.sourceReplayPath) : [];
+ }
+ const items = this.replayPathPosition < this.replayPath.length
+ ? this.filterOnReplay(itemsRaw)
+ : this.filterOnExecution(itemsRaw);
+ this.replayPathPosition += itemsRaw.length;
+ return items;
+ }
+ shrink(_value, context) {
+ if (context === undefined) {
+ return Stream.nil();
+ }
+ const safeContext = context;
+ const shrunkOnce = safeContext.shrunkOnce;
+ const itemsRaw = safeContext.items;
+ const items = this.filterForShrinkImpl(itemsRaw);
+ if (items.length === 0) {
+ return Stream.nil();
+ }
+ const rootShrink = shrunkOnce
+ ? Stream.nil()
+ : new Stream([[]][Symbol.iterator]());
+ const nextShrinks = [];
+ for (let numToKeep = 0; numToKeep !== items.length; ++numToKeep) {
+ nextShrinks.push(makeLazy(() => {
+ const fixedStart = items.slice(0, numToKeep);
+ return this.lengthArb
+ .shrink(items.length - 1 - numToKeep, undefined)
+ .map((l) => fixedStart.concat(items.slice(items.length - (l.value + 1))));
+ }));
+ }
+ for (let itemAt = 0; itemAt !== items.length; ++itemAt) {
+ nextShrinks.push(makeLazy(() => this.oneCommandArb
+ .shrink(items[itemAt].value_, items[itemAt].context)
+ .map((v) => items.slice(0, itemAt).concat([v], items.slice(itemAt + 1)))));
+ }
+ return rootShrink.join(...nextShrinks).map((shrinkables) => {
+ return this.buildValueFor(shrinkables.map((c) => new Value(c.value_.clone(), c.context)), true);
+ });
+ }
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/ConstantArbitrary.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/ConstantArbitrary.js
new file mode 100644
index 0000000000000000000000000000000000000000..61e078ede2a6ce22c4289bb99384c8ead20e27dc
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/ConstantArbitrary.js
@@ -0,0 +1,61 @@
+import { Stream } from '../../stream/Stream.js';
+import { Arbitrary } from '../../check/arbitrary/definition/Arbitrary.js';
+import { Value } from '../../check/arbitrary/definition/Value.js';
+import { cloneMethod, hasCloneMethod } from '../../check/symbols.js';
+import { Set, safeHas } from '../../utils/globals.js';
+const safeObjectIs = Object.is;
+export class ConstantArbitrary extends Arbitrary {
+ constructor(values) {
+ super();
+ this.values = values;
+ }
+ generate(mrng, _biasFactor) {
+ const idx = this.values.length === 1 ? 0 : mrng.nextInt(0, this.values.length - 1);
+ const value = this.values[idx];
+ if (!hasCloneMethod(value)) {
+ return new Value(value, idx);
+ }
+ return new Value(value, idx, () => value[cloneMethod]());
+ }
+ canShrinkWithoutContext(value) {
+ if (this.values.length === 1) {
+ return safeObjectIs(this.values[0], value);
+ }
+ if (this.fastValues === undefined) {
+ this.fastValues = new FastConstantValuesLookup(this.values);
+ }
+ return this.fastValues.has(value);
+ }
+ shrink(value, context) {
+ if (context === 0 || safeObjectIs(value, this.values[0])) {
+ return Stream.nil();
+ }
+ return Stream.of(new Value(this.values[0], 0));
+ }
+}
+class FastConstantValuesLookup {
+ constructor(values) {
+ this.values = values;
+ this.fastValues = new Set(this.values);
+ let hasMinusZero = false;
+ let hasPlusZero = false;
+ if (safeHas(this.fastValues, 0)) {
+ for (let idx = 0; idx !== this.values.length; ++idx) {
+ const value = this.values[idx];
+ hasMinusZero = hasMinusZero || safeObjectIs(value, -0);
+ hasPlusZero = hasPlusZero || safeObjectIs(value, 0);
+ }
+ }
+ this.hasMinusZero = hasMinusZero;
+ this.hasPlusZero = hasPlusZero;
+ }
+ has(value) {
+ if (value === 0) {
+ if (safeObjectIs(value, 0)) {
+ return this.hasPlusZero;
+ }
+ return this.hasMinusZero;
+ }
+ return safeHas(this.fastValues, value);
+ }
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/FrequencyArbitrary.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/FrequencyArbitrary.js
new file mode 100644
index 0000000000000000000000000000000000000000..ea1cf81cc6579bca52501cd547fb1027a4ca19ef
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/FrequencyArbitrary.js
@@ -0,0 +1,162 @@
+import { Stream } from '../../stream/Stream.js';
+import { Arbitrary } from '../../check/arbitrary/definition/Arbitrary.js';
+import { Value } from '../../check/arbitrary/definition/Value.js';
+import { getDepthContextFor } from './helpers/DepthContext.js';
+import { depthBiasFromSizeForArbitrary } from './helpers/MaxLengthFromMinLength.js';
+import { safePush } from '../../utils/globals.js';
+const safePositiveInfinity = Number.POSITIVE_INFINITY;
+const safeMaxSafeInteger = Number.MAX_SAFE_INTEGER;
+const safeNumberIsInteger = Number.isInteger;
+const safeMathFloor = Math.floor;
+const safeMathPow = Math.pow;
+const safeMathMin = Math.min;
+export class FrequencyArbitrary extends Arbitrary {
+ static from(warbs, constraints, label) {
+ if (warbs.length === 0) {
+ throw new Error(`${label} expects at least one weighted arbitrary`);
+ }
+ let totalWeight = 0;
+ for (let idx = 0; idx !== warbs.length; ++idx) {
+ const currentArbitrary = warbs[idx].arbitrary;
+ if (currentArbitrary === undefined) {
+ throw new Error(`${label} expects arbitraries to be specified`);
+ }
+ const currentWeight = warbs[idx].weight;
+ totalWeight += currentWeight;
+ if (!safeNumberIsInteger(currentWeight)) {
+ throw new Error(`${label} expects weights to be integer values`);
+ }
+ if (currentWeight < 0) {
+ throw new Error(`${label} expects weights to be superior or equal to 0`);
+ }
+ }
+ if (totalWeight <= 0) {
+ throw new Error(`${label} expects the sum of weights to be strictly superior to 0`);
+ }
+ const sanitizedConstraints = {
+ depthBias: depthBiasFromSizeForArbitrary(constraints.depthSize, constraints.maxDepth !== undefined),
+ maxDepth: constraints.maxDepth != undefined ? constraints.maxDepth : safePositiveInfinity,
+ withCrossShrink: !!constraints.withCrossShrink,
+ };
+ return new FrequencyArbitrary(warbs, sanitizedConstraints, getDepthContextFor(constraints.depthIdentifier));
+ }
+ constructor(warbs, constraints, context) {
+ super();
+ this.warbs = warbs;
+ this.constraints = constraints;
+ this.context = context;
+ let currentWeight = 0;
+ this.cumulatedWeights = [];
+ for (let idx = 0; idx !== warbs.length; ++idx) {
+ currentWeight += warbs[idx].weight;
+ safePush(this.cumulatedWeights, currentWeight);
+ }
+ this.totalWeight = currentWeight;
+ }
+ generate(mrng, biasFactor) {
+ if (this.mustGenerateFirst()) {
+ return this.safeGenerateForIndex(mrng, 0, biasFactor);
+ }
+ const selected = mrng.nextInt(this.computeNegDepthBenefit(), this.totalWeight - 1);
+ for (let idx = 0; idx !== this.cumulatedWeights.length; ++idx) {
+ if (selected < this.cumulatedWeights[idx]) {
+ return this.safeGenerateForIndex(mrng, idx, biasFactor);
+ }
+ }
+ throw new Error(`Unable to generate from fc.frequency`);
+ }
+ canShrinkWithoutContext(value) {
+ return this.canShrinkWithoutContextIndex(value) !== -1;
+ }
+ shrink(value, context) {
+ if (context !== undefined) {
+ const safeContext = context;
+ const selectedIndex = safeContext.selectedIndex;
+ const originalBias = safeContext.originalBias;
+ const originalArbitrary = this.warbs[selectedIndex].arbitrary;
+ const originalShrinks = originalArbitrary
+ .shrink(value, safeContext.originalContext)
+ .map((v) => this.mapIntoValue(selectedIndex, v, null, originalBias));
+ if (safeContext.clonedMrngForFallbackFirst !== null) {
+ if (safeContext.cachedGeneratedForFirst === undefined) {
+ safeContext.cachedGeneratedForFirst = this.safeGenerateForIndex(safeContext.clonedMrngForFallbackFirst, 0, originalBias);
+ }
+ const valueFromFirst = safeContext.cachedGeneratedForFirst;
+ return Stream.of(valueFromFirst).join(originalShrinks);
+ }
+ return originalShrinks;
+ }
+ const potentialSelectedIndex = this.canShrinkWithoutContextIndex(value);
+ if (potentialSelectedIndex === -1) {
+ return Stream.nil();
+ }
+ return this.defaultShrinkForFirst(potentialSelectedIndex).join(this.warbs[potentialSelectedIndex].arbitrary
+ .shrink(value, undefined)
+ .map((v) => this.mapIntoValue(potentialSelectedIndex, v, null, undefined)));
+ }
+ defaultShrinkForFirst(selectedIndex) {
+ ++this.context.depth;
+ try {
+ if (!this.mustFallbackToFirstInShrink(selectedIndex) || this.warbs[0].fallbackValue === undefined) {
+ return Stream.nil();
+ }
+ }
+ finally {
+ --this.context.depth;
+ }
+ const rawShrinkValue = new Value(this.warbs[0].fallbackValue.default, undefined);
+ return Stream.of(this.mapIntoValue(0, rawShrinkValue, null, undefined));
+ }
+ canShrinkWithoutContextIndex(value) {
+ if (this.mustGenerateFirst()) {
+ return this.warbs[0].arbitrary.canShrinkWithoutContext(value) ? 0 : -1;
+ }
+ try {
+ ++this.context.depth;
+ for (let idx = 0; idx !== this.warbs.length; ++idx) {
+ const warb = this.warbs[idx];
+ if (warb.weight !== 0 && warb.arbitrary.canShrinkWithoutContext(value)) {
+ return idx;
+ }
+ }
+ return -1;
+ }
+ finally {
+ --this.context.depth;
+ }
+ }
+ mapIntoValue(idx, value, clonedMrngForFallbackFirst, biasFactor) {
+ const context = {
+ selectedIndex: idx,
+ originalBias: biasFactor,
+ originalContext: value.context,
+ clonedMrngForFallbackFirst,
+ };
+ return new Value(value.value, context);
+ }
+ safeGenerateForIndex(mrng, idx, biasFactor) {
+ ++this.context.depth;
+ try {
+ const value = this.warbs[idx].arbitrary.generate(mrng, biasFactor);
+ const clonedMrngForFallbackFirst = this.mustFallbackToFirstInShrink(idx) ? mrng.clone() : null;
+ return this.mapIntoValue(idx, value, clonedMrngForFallbackFirst, biasFactor);
+ }
+ finally {
+ --this.context.depth;
+ }
+ }
+ mustGenerateFirst() {
+ return this.constraints.maxDepth <= this.context.depth;
+ }
+ mustFallbackToFirstInShrink(idx) {
+ return idx !== 0 && this.constraints.withCrossShrink && this.warbs[0].weight !== 0;
+ }
+ computeNegDepthBenefit() {
+ const depthBias = this.constraints.depthBias;
+ if (depthBias <= 0 || this.warbs[0].weight === 0) {
+ return 0;
+ }
+ const depthBenefit = safeMathFloor(safeMathPow(1 + depthBias, this.context.depth)) - 1;
+ return -safeMathMin(this.totalWeight * depthBenefit, safeMaxSafeInteger) || 0;
+ }
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/GeneratorArbitrary.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/GeneratorArbitrary.js
new file mode 100644
index 0000000000000000000000000000000000000000..3b6e9f8230cdf4db34f893dadc224d1b87952648
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/GeneratorArbitrary.js
@@ -0,0 +1,40 @@
+import { Arbitrary } from '../../check/arbitrary/definition/Arbitrary.js';
+import { Stream } from '../../stream/Stream.js';
+import { safeMap } from '../../utils/globals.js';
+import { buildGeneratorValue } from './builders/GeneratorValueBuilder.js';
+import { buildStableArbitraryGeneratorCache, naiveIsEqual } from './builders/StableArbitraryGeneratorCache.js';
+import { tupleShrink } from './TupleArbitrary.js';
+export class GeneratorArbitrary extends Arbitrary {
+ constructor() {
+ super(...arguments);
+ this.arbitraryCache = buildStableArbitraryGeneratorCache(naiveIsEqual);
+ }
+ generate(mrng, biasFactor) {
+ return buildGeneratorValue(mrng, biasFactor, () => [], this.arbitraryCache);
+ }
+ canShrinkWithoutContext(value) {
+ return false;
+ }
+ shrink(_value, context) {
+ if (context === undefined) {
+ return Stream.nil();
+ }
+ const safeContext = context;
+ const mrng = safeContext.mrng;
+ const biasFactor = safeContext.biasFactor;
+ const history = safeContext.history;
+ return tupleShrink(history.map((c) => c.arb), history.map((c) => c.value), history.map((c) => c.context)).map((shrink) => {
+ function computePreBuiltValues() {
+ const subValues = shrink.value;
+ const subContexts = shrink.context;
+ return safeMap(history, (entry, index) => ({
+ arb: entry.arb,
+ value: subValues[index],
+ context: subContexts[index],
+ mrng: entry.mrng,
+ }));
+ }
+ return buildGeneratorValue(mrng, biasFactor, computePreBuiltValues, this.arbitraryCache);
+ });
+ }
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/IntegerArbitrary.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/IntegerArbitrary.js
new file mode 100644
index 0000000000000000000000000000000000000000..92544b7ebfde473bf70f014fda14aae72d17b2c4
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/IntegerArbitrary.js
@@ -0,0 +1,72 @@
+import { Arbitrary } from '../../check/arbitrary/definition/Arbitrary.js';
+import { Value } from '../../check/arbitrary/definition/Value.js';
+import { Stream } from '../../stream/Stream.js';
+import { integerLogLike, biasNumericRange } from './helpers/BiasNumericRange.js';
+import { shrinkInteger } from './helpers/ShrinkInteger.js';
+const safeMathSign = Math.sign;
+const safeNumberIsInteger = Number.isInteger;
+const safeObjectIs = Object.is;
+export class IntegerArbitrary extends Arbitrary {
+ constructor(min, max) {
+ super();
+ this.min = min;
+ this.max = max;
+ }
+ generate(mrng, biasFactor) {
+ const range = this.computeGenerateRange(mrng, biasFactor);
+ return new Value(mrng.nextInt(range.min, range.max), undefined);
+ }
+ canShrinkWithoutContext(value) {
+ return (typeof value === 'number' &&
+ safeNumberIsInteger(value) &&
+ !safeObjectIs(value, -0) &&
+ this.min <= value &&
+ value <= this.max);
+ }
+ shrink(current, context) {
+ if (!IntegerArbitrary.isValidContext(current, context)) {
+ const target = this.defaultTarget();
+ return shrinkInteger(current, target, true);
+ }
+ if (this.isLastChanceTry(current, context)) {
+ return Stream.of(new Value(context, undefined));
+ }
+ return shrinkInteger(current, context, false);
+ }
+ defaultTarget() {
+ if (this.min <= 0 && this.max >= 0) {
+ return 0;
+ }
+ return this.min < 0 ? this.max : this.min;
+ }
+ computeGenerateRange(mrng, biasFactor) {
+ if (biasFactor === undefined || mrng.nextInt(1, biasFactor) !== 1) {
+ return { min: this.min, max: this.max };
+ }
+ const ranges = biasNumericRange(this.min, this.max, integerLogLike);
+ if (ranges.length === 1) {
+ return ranges[0];
+ }
+ const id = mrng.nextInt(-2 * (ranges.length - 1), ranges.length - 2);
+ return id < 0 ? ranges[0] : ranges[id + 1];
+ }
+ isLastChanceTry(current, context) {
+ if (current > 0)
+ return current === context + 1 && current > this.min;
+ if (current < 0)
+ return current === context - 1 && current < this.max;
+ return false;
+ }
+ static isValidContext(current, context) {
+ if (context === undefined) {
+ return false;
+ }
+ if (typeof context !== 'number') {
+ throw new Error(`Invalid context type passed to IntegerArbitrary (#1)`);
+ }
+ if (context !== 0 && safeMathSign(current) !== safeMathSign(context)) {
+ throw new Error(`Invalid context value passed to IntegerArbitrary (#2)`);
+ }
+ return true;
+ }
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/LazyArbitrary.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/LazyArbitrary.js
new file mode 100644
index 0000000000000000000000000000000000000000..99dc455cca5ab41530a00f74bdb82ce9d1d4ef03
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/LazyArbitrary.js
@@ -0,0 +1,26 @@
+import { Arbitrary } from '../../check/arbitrary/definition/Arbitrary.js';
+export class LazyArbitrary extends Arbitrary {
+ constructor(name) {
+ super();
+ this.name = name;
+ this.underlying = null;
+ }
+ generate(mrng, biasFactor) {
+ if (!this.underlying) {
+ throw new Error(`Lazy arbitrary ${JSON.stringify(this.name)} not correctly initialized`);
+ }
+ return this.underlying.generate(mrng, biasFactor);
+ }
+ canShrinkWithoutContext(value) {
+ if (!this.underlying) {
+ throw new Error(`Lazy arbitrary ${JSON.stringify(this.name)} not correctly initialized`);
+ }
+ return this.underlying.canShrinkWithoutContext(value);
+ }
+ shrink(value, context) {
+ if (!this.underlying) {
+ throw new Error(`Lazy arbitrary ${JSON.stringify(this.name)} not correctly initialized`);
+ }
+ return this.underlying.shrink(value, context);
+ }
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/LimitedShrinkArbitrary.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/LimitedShrinkArbitrary.js
new file mode 100644
index 0000000000000000000000000000000000000000..afb593a00f323e301979718db79564d8b9f66547
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/LimitedShrinkArbitrary.js
@@ -0,0 +1,50 @@
+import { Arbitrary } from '../../check/arbitrary/definition/Arbitrary.js';
+import { Value } from '../../check/arbitrary/definition/Value.js';
+import { Stream } from '../../stream/Stream.js';
+import { zipIterableIterators } from './helpers/ZipIterableIterators.js';
+function* iotaFrom(startValue) {
+ let value = startValue;
+ while (true) {
+ yield value;
+ ++value;
+ }
+}
+export class LimitedShrinkArbitrary extends Arbitrary {
+ constructor(arb, maxShrinks) {
+ super();
+ this.arb = arb;
+ this.maxShrinks = maxShrinks;
+ }
+ generate(mrng, biasFactor) {
+ const value = this.arb.generate(mrng, biasFactor);
+ return this.valueMapper(value, 0);
+ }
+ canShrinkWithoutContext(value) {
+ return this.arb.canShrinkWithoutContext(value);
+ }
+ shrink(value, context) {
+ if (this.isSafeContext(context)) {
+ return this.safeShrink(value, context.originalContext, context.length);
+ }
+ return this.safeShrink(value, undefined, 0);
+ }
+ safeShrink(value, originalContext, currentLength) {
+ const remaining = this.maxShrinks - currentLength;
+ if (remaining <= 0) {
+ return Stream.nil();
+ }
+ return new Stream(zipIterableIterators(this.arb.shrink(value, originalContext), iotaFrom(currentLength + 1)))
+ .take(remaining)
+ .map((valueAndLength) => this.valueMapper(valueAndLength[0], valueAndLength[1]));
+ }
+ valueMapper(v, newLength) {
+ const context = { originalContext: v.context, length: newLength };
+ return new Value(v.value, context);
+ }
+ isSafeContext(context) {
+ return (context != null &&
+ typeof context === 'object' &&
+ 'originalContext' in context &&
+ 'length' in context);
+ }
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/MixedCaseArbitrary.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/MixedCaseArbitrary.js
new file mode 100644
index 0000000000000000000000000000000000000000..b62c0c2902a26cb72e7dd7d360cd46fc9457026e
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/MixedCaseArbitrary.js
@@ -0,0 +1,91 @@
+import { bigUintN } from '../bigUintN.js';
+import { Arbitrary } from '../../check/arbitrary/definition/Arbitrary.js';
+import { Value } from '../../check/arbitrary/definition/Value.js';
+import { makeLazy } from '../../stream/LazyIterableIterator.js';
+import { applyFlagsOnChars, computeFlagsFromChars, computeNextFlags, computeTogglePositions, } from './helpers/ToggleFlags.js';
+import { safeJoin, safeSlice } from '../../utils/globals.js';
+import { BigInt } from '../../utils/globals.js';
+export class MixedCaseArbitrary extends Arbitrary {
+ constructor(stringArb, toggleCase, untoggleAll) {
+ super();
+ this.stringArb = stringArb;
+ this.toggleCase = toggleCase;
+ this.untoggleAll = untoggleAll;
+ }
+ buildContextFor(rawStringValue, flagsValue) {
+ return {
+ rawString: rawStringValue.value,
+ rawStringContext: rawStringValue.context,
+ flags: flagsValue.value,
+ flagsContext: flagsValue.context,
+ };
+ }
+ generate(mrng, biasFactor) {
+ const rawStringValue = this.stringArb.generate(mrng, biasFactor);
+ const chars = [...rawStringValue.value];
+ const togglePositions = computeTogglePositions(chars, this.toggleCase);
+ const flagsArb = bigUintN(togglePositions.length);
+ const flagsValue = flagsArb.generate(mrng, undefined);
+ applyFlagsOnChars(chars, flagsValue.value, togglePositions, this.toggleCase);
+ return new Value(safeJoin(chars, ''), this.buildContextFor(rawStringValue, flagsValue));
+ }
+ canShrinkWithoutContext(value) {
+ if (typeof value !== 'string') {
+ return false;
+ }
+ return this.untoggleAll !== undefined
+ ? this.stringArb.canShrinkWithoutContext(this.untoggleAll(value))
+ :
+ this.stringArb.canShrinkWithoutContext(value);
+ }
+ shrink(value, context) {
+ let contextSafe;
+ if (context !== undefined) {
+ contextSafe = context;
+ }
+ else {
+ if (this.untoggleAll !== undefined) {
+ const untoggledValue = this.untoggleAll(value);
+ const valueChars = [...value];
+ const untoggledValueChars = [...untoggledValue];
+ const togglePositions = computeTogglePositions(untoggledValueChars, this.toggleCase);
+ contextSafe = {
+ rawString: untoggledValue,
+ rawStringContext: undefined,
+ flags: computeFlagsFromChars(untoggledValueChars, valueChars, togglePositions),
+ flagsContext: undefined,
+ };
+ }
+ else {
+ contextSafe = {
+ rawString: value,
+ rawStringContext: undefined,
+ flags: BigInt(0),
+ flagsContext: undefined,
+ };
+ }
+ }
+ const rawString = contextSafe.rawString;
+ const flags = contextSafe.flags;
+ return this.stringArb
+ .shrink(rawString, contextSafe.rawStringContext)
+ .map((nRawStringValue) => {
+ const nChars = [...nRawStringValue.value];
+ const nTogglePositions = computeTogglePositions(nChars, this.toggleCase);
+ const nFlags = computeNextFlags(flags, nTogglePositions.length);
+ applyFlagsOnChars(nChars, nFlags, nTogglePositions, this.toggleCase);
+ return new Value(safeJoin(nChars, ''), this.buildContextFor(nRawStringValue, new Value(nFlags, undefined)));
+ })
+ .join(makeLazy(() => {
+ const chars = [...rawString];
+ const togglePositions = computeTogglePositions(chars, this.toggleCase);
+ return bigUintN(togglePositions.length)
+ .shrink(flags, contextSafe.flagsContext)
+ .map((nFlagsValue) => {
+ const nChars = safeSlice(chars);
+ applyFlagsOnChars(nChars, nFlagsValue.value, togglePositions, this.toggleCase);
+ return new Value(safeJoin(nChars, ''), this.buildContextFor(new Value(rawString, contextSafe.rawStringContext), nFlagsValue));
+ });
+ }));
+ }
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/SchedulerArbitrary.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/SchedulerArbitrary.js
new file mode 100644
index 0000000000000000000000000000000000000000..b620be734e2dc24e88ff24bafefc538d8515eb9c
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/SchedulerArbitrary.js
@@ -0,0 +1,28 @@
+import { Arbitrary } from '../../check/arbitrary/definition/Arbitrary.js';
+import { Value } from '../../check/arbitrary/definition/Value.js';
+import { Stream } from '../../stream/Stream.js';
+import { SchedulerImplem } from './implementations/SchedulerImplem.js';
+function buildNextTaskIndex(mrng) {
+ const clonedMrng = mrng.clone();
+ return {
+ clone: () => buildNextTaskIndex(clonedMrng),
+ nextTaskIndex: (scheduledTasks) => {
+ return mrng.nextInt(0, scheduledTasks.length - 1);
+ },
+ };
+}
+export class SchedulerArbitrary extends Arbitrary {
+ constructor(act) {
+ super();
+ this.act = act;
+ }
+ generate(mrng, _biasFactor) {
+ return new Value(new SchedulerImplem(this.act, buildNextTaskIndex(mrng.clone())), undefined);
+ }
+ canShrinkWithoutContext(value) {
+ return false;
+ }
+ shrink(_value, _context) {
+ return Stream.nil();
+ }
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/StreamArbitrary.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/StreamArbitrary.js
new file mode 100644
index 0000000000000000000000000000000000000000..013d306a4018d40ea387358f089fcb1c8278b75f
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/StreamArbitrary.js
@@ -0,0 +1,43 @@
+import { Arbitrary } from '../../check/arbitrary/definition/Arbitrary.js';
+import { Value } from '../../check/arbitrary/definition/Value.js';
+import { cloneMethod } from '../../check/symbols.js';
+import { Stream } from '../../stream/Stream.js';
+import { safeJoin, safePush } from '../../utils/globals.js';
+import { asyncStringify, asyncToStringMethod, stringify, toStringMethod } from '../../utils/stringify.js';
+const safeObjectDefineProperties = Object.defineProperties;
+function prettyPrint(seenValuesStrings) {
+ return `Stream(${safeJoin(seenValuesStrings, ',')}…)`;
+}
+export class StreamArbitrary extends Arbitrary {
+ constructor(arb) {
+ super();
+ this.arb = arb;
+ }
+ generate(mrng, biasFactor) {
+ const appliedBiasFactor = biasFactor !== undefined && mrng.nextInt(1, biasFactor) === 1 ? biasFactor : undefined;
+ const enrichedProducer = () => {
+ const seenValues = [];
+ const g = function* (arb, clonedMrng) {
+ while (true) {
+ const value = arb.generate(clonedMrng, appliedBiasFactor).value;
+ safePush(seenValues, value);
+ yield value;
+ }
+ };
+ const s = new Stream(g(this.arb, mrng.clone()));
+ return safeObjectDefineProperties(s, {
+ toString: { value: () => prettyPrint(seenValues.map(stringify)) },
+ [toStringMethod]: { value: () => prettyPrint(seenValues.map(stringify)) },
+ [asyncToStringMethod]: { value: async () => prettyPrint(await Promise.all(seenValues.map(asyncStringify))) },
+ [cloneMethod]: { value: enrichedProducer, enumerable: true },
+ });
+ };
+ return new Value(enrichedProducer(), undefined);
+ }
+ canShrinkWithoutContext(value) {
+ return false;
+ }
+ shrink(_value, _context) {
+ return Stream.nil();
+ }
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/StringUnitArbitrary.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/StringUnitArbitrary.js
new file mode 100644
index 0000000000000000000000000000000000000000..36d50aa7a5fc74c4a472fcca11294f7a43cc2f02
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/StringUnitArbitrary.js
@@ -0,0 +1,42 @@
+import { safeNormalize, safePush } from '../../utils/globals.js';
+import { mapToConstant } from '../mapToConstant.js';
+import { asciiAlphabetRanges, autonomousDecomposableGraphemeRanges, autonomousGraphemeRanges, fullAlphabetRanges, } from './data/GraphemeRanges.js';
+import { convertGraphemeRangeToMapToConstantEntry, intersectGraphemeRanges } from './helpers/GraphemeRangesHelpers.js';
+const registeredStringUnitInstancesMap = Object.create(null);
+function getAlphabetRanges(alphabet) {
+ switch (alphabet) {
+ case 'full':
+ return fullAlphabetRanges;
+ case 'ascii':
+ return asciiAlphabetRanges;
+ }
+}
+function getOrCreateStringUnitInstance(type, alphabet) {
+ const key = `${type}:${alphabet}`;
+ const registered = registeredStringUnitInstancesMap[key];
+ if (registered !== undefined) {
+ return registered;
+ }
+ const alphabetRanges = getAlphabetRanges(alphabet);
+ const ranges = type === 'binary' ? alphabetRanges : intersectGraphemeRanges(alphabetRanges, autonomousGraphemeRanges);
+ const entries = [];
+ for (const range of ranges) {
+ safePush(entries, convertGraphemeRangeToMapToConstantEntry(range));
+ }
+ if (type === 'grapheme') {
+ const decomposedRanges = intersectGraphemeRanges(alphabetRanges, autonomousDecomposableGraphemeRanges);
+ for (const range of decomposedRanges) {
+ const rawEntry = convertGraphemeRangeToMapToConstantEntry(range);
+ safePush(entries, {
+ num: rawEntry.num,
+ build: (idInGroup) => safeNormalize(rawEntry.build(idInGroup), 'NFD'),
+ });
+ }
+ }
+ const stringUnitInstance = mapToConstant(...entries);
+ registeredStringUnitInstancesMap[key] = stringUnitInstance;
+ return stringUnitInstance;
+}
+export function stringUnit(type, alphabet) {
+ return getOrCreateStringUnitInstance(type, alphabet);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/SubarrayArbitrary.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/SubarrayArbitrary.js
new file mode 100644
index 0000000000000000000000000000000000000000..d659af9c7ded4f42f3966830c1c8510727af7128
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/SubarrayArbitrary.js
@@ -0,0 +1,70 @@
+import { Arbitrary } from '../../check/arbitrary/definition/Arbitrary.js';
+import { Value } from '../../check/arbitrary/definition/Value.js';
+import { makeLazy } from '../../stream/LazyIterableIterator.js';
+import { Stream } from '../../stream/Stream.js';
+import { safeMap, safePush, safeSlice, safeSort, safeSplice } from '../../utils/globals.js';
+import { isSubarrayOf } from './helpers/IsSubarrayOf.js';
+import { IntegerArbitrary } from './IntegerArbitrary.js';
+const safeMathFloor = Math.floor;
+const safeMathLog = Math.log;
+const safeArrayIsArray = Array.isArray;
+export class SubarrayArbitrary extends Arbitrary {
+ constructor(originalArray, isOrdered, minLength, maxLength) {
+ super();
+ this.originalArray = originalArray;
+ this.isOrdered = isOrdered;
+ this.minLength = minLength;
+ this.maxLength = maxLength;
+ if (minLength < 0 || minLength > originalArray.length)
+ throw new Error('fc.*{s|S}ubarrayOf expects the minimal length to be between 0 and the size of the original array');
+ if (maxLength < 0 || maxLength > originalArray.length)
+ throw new Error('fc.*{s|S}ubarrayOf expects the maximal length to be between 0 and the size of the original array');
+ if (minLength > maxLength)
+ throw new Error('fc.*{s|S}ubarrayOf expects the minimal length to be inferior or equal to the maximal length');
+ this.lengthArb = new IntegerArbitrary(minLength, maxLength);
+ this.biasedLengthArb =
+ minLength !== maxLength
+ ? new IntegerArbitrary(minLength, minLength + safeMathFloor(safeMathLog(maxLength - minLength) / safeMathLog(2)))
+ : this.lengthArb;
+ }
+ generate(mrng, biasFactor) {
+ const lengthArb = biasFactor !== undefined && mrng.nextInt(1, biasFactor) === 1 ? this.biasedLengthArb : this.lengthArb;
+ const size = lengthArb.generate(mrng, undefined);
+ const sizeValue = size.value;
+ const remainingElements = safeMap(this.originalArray, (_v, idx) => idx);
+ const ids = [];
+ for (let index = 0; index !== sizeValue; ++index) {
+ const selectedIdIndex = mrng.nextInt(0, remainingElements.length - 1);
+ safePush(ids, remainingElements[selectedIdIndex]);
+ safeSplice(remainingElements, selectedIdIndex, 1);
+ }
+ if (this.isOrdered) {
+ safeSort(ids, (a, b) => a - b);
+ }
+ return new Value(safeMap(ids, (i) => this.originalArray[i]), size.context);
+ }
+ canShrinkWithoutContext(value) {
+ if (!safeArrayIsArray(value)) {
+ return false;
+ }
+ if (!this.lengthArb.canShrinkWithoutContext(value.length)) {
+ return false;
+ }
+ return isSubarrayOf(this.originalArray, value);
+ }
+ shrink(value, context) {
+ if (value.length === 0) {
+ return Stream.nil();
+ }
+ return this.lengthArb
+ .shrink(value.length, context)
+ .map((newSize) => {
+ return new Value(safeSlice(value, value.length - newSize.value), newSize.context);
+ })
+ .join(value.length > this.minLength
+ ? makeLazy(() => this.shrink(safeSlice(value, 1), undefined)
+ .filter((newValue) => this.minLength <= newValue.value.length + 1)
+ .map((newValue) => new Value([value[0], ...newValue.value], undefined)))
+ : Stream.nil());
+ }
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/TupleArbitrary.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/TupleArbitrary.js
new file mode 100644
index 0000000000000000000000000000000000000000..86b90af465b2cba8430618395343e3ffc95eac17
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/TupleArbitrary.js
@@ -0,0 +1,81 @@
+import { Stream } from '../../stream/Stream.js';
+import { cloneIfNeeded, cloneMethod } from '../../check/symbols.js';
+import { Arbitrary } from '../../check/arbitrary/definition/Arbitrary.js';
+import { Value } from '../../check/arbitrary/definition/Value.js';
+import { safeMap, safePush, safeSlice } from '../../utils/globals.js';
+import { makeLazy } from '../../stream/LazyIterableIterator.js';
+const safeArrayIsArray = Array.isArray;
+const safeObjectDefineProperty = Object.defineProperty;
+function tupleMakeItCloneable(vs, values) {
+ return safeObjectDefineProperty(vs, cloneMethod, {
+ value: () => {
+ const cloned = [];
+ for (let idx = 0; idx !== values.length; ++idx) {
+ safePush(cloned, values[idx].value);
+ }
+ tupleMakeItCloneable(cloned, values);
+ return cloned;
+ },
+ });
+}
+function tupleWrapper(values) {
+ let cloneable = false;
+ const vs = [];
+ const ctxs = [];
+ for (let idx = 0; idx !== values.length; ++idx) {
+ const v = values[idx];
+ cloneable = cloneable || v.hasToBeCloned;
+ safePush(vs, v.value);
+ safePush(ctxs, v.context);
+ }
+ if (cloneable) {
+ tupleMakeItCloneable(vs, values);
+ }
+ return new Value(vs, ctxs);
+}
+export function tupleShrink(arbs, value, context) {
+ const shrinks = [];
+ const safeContext = safeArrayIsArray(context) ? context : [];
+ for (let idx = 0; idx !== arbs.length; ++idx) {
+ safePush(shrinks, makeLazy(() => arbs[idx]
+ .shrink(value[idx], safeContext[idx])
+ .map((v) => {
+ const nextValues = safeMap(value, (v, idx) => new Value(cloneIfNeeded(v), safeContext[idx]));
+ return [...safeSlice(nextValues, 0, idx), v, ...safeSlice(nextValues, idx + 1)];
+ })
+ .map(tupleWrapper)));
+ }
+ return Stream.nil().join(...shrinks);
+}
+export class TupleArbitrary extends Arbitrary {
+ constructor(arbs) {
+ super();
+ this.arbs = arbs;
+ for (let idx = 0; idx !== arbs.length; ++idx) {
+ const arb = arbs[idx];
+ if (arb == null || arb.generate == null)
+ throw new Error(`Invalid parameter encountered at index ${idx}: expecting an Arbitrary`);
+ }
+ }
+ generate(mrng, biasFactor) {
+ const mapped = [];
+ for (let idx = 0; idx !== this.arbs.length; ++idx) {
+ safePush(mapped, this.arbs[idx].generate(mrng, biasFactor));
+ }
+ return tupleWrapper(mapped);
+ }
+ canShrinkWithoutContext(value) {
+ if (!safeArrayIsArray(value) || value.length !== this.arbs.length) {
+ return false;
+ }
+ for (let index = 0; index !== this.arbs.length; ++index) {
+ if (!this.arbs[index].canShrinkWithoutContext(value[index])) {
+ return false;
+ }
+ }
+ return true;
+ }
+ shrink(value, context) {
+ return tupleShrink(this.arbs, value, context);
+ }
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/WithShrinkFromOtherArbitrary.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/WithShrinkFromOtherArbitrary.js
new file mode 100644
index 0000000000000000000000000000000000000000..1c6599c20f3f9c64fbb112a6b2c6dbcffbfd3a21
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/WithShrinkFromOtherArbitrary.js
@@ -0,0 +1,39 @@
+import { Arbitrary } from '../../check/arbitrary/definition/Arbitrary.js';
+import { Value } from '../../check/arbitrary/definition/Value.js';
+function isSafeContext(context) {
+ return context !== undefined;
+}
+function toGeneratorValue(value) {
+ if (value.hasToBeCloned) {
+ return new Value(value.value_, { generatorContext: value.context }, () => value.value);
+ }
+ return new Value(value.value_, { generatorContext: value.context });
+}
+function toShrinkerValue(value) {
+ if (value.hasToBeCloned) {
+ return new Value(value.value_, { shrinkerContext: value.context }, () => value.value);
+ }
+ return new Value(value.value_, { shrinkerContext: value.context });
+}
+export class WithShrinkFromOtherArbitrary extends Arbitrary {
+ constructor(generatorArbitrary, shrinkerArbitrary) {
+ super();
+ this.generatorArbitrary = generatorArbitrary;
+ this.shrinkerArbitrary = shrinkerArbitrary;
+ }
+ generate(mrng, biasFactor) {
+ return toGeneratorValue(this.generatorArbitrary.generate(mrng, biasFactor));
+ }
+ canShrinkWithoutContext(value) {
+ return this.shrinkerArbitrary.canShrinkWithoutContext(value);
+ }
+ shrink(value, context) {
+ if (!isSafeContext(context)) {
+ return this.shrinkerArbitrary.shrink(value, undefined).map(toShrinkerValue);
+ }
+ if ('generatorContext' in context) {
+ return this.generatorArbitrary.shrink(value, context.generatorContext).map(toGeneratorValue);
+ }
+ return this.shrinkerArbitrary.shrink(value, context.shrinkerContext).map(toShrinkerValue);
+ }
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/AnyArbitraryBuilder.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/AnyArbitraryBuilder.js
new file mode 100644
index 0000000000000000000000000000000000000000..faab0244ac6f18570852d69827120c7d69a94c87
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/AnyArbitraryBuilder.js
@@ -0,0 +1,66 @@
+import { stringify } from '../../../utils/stringify.js';
+import { array } from '../../array.js';
+import { oneof } from '../../oneof.js';
+import { tuple } from '../../tuple.js';
+import { bigInt } from '../../bigInt.js';
+import { date } from '../../date.js';
+import { float32Array } from '../../float32Array.js';
+import { float64Array } from '../../float64Array.js';
+import { int16Array } from '../../int16Array.js';
+import { int32Array } from '../../int32Array.js';
+import { int8Array } from '../../int8Array.js';
+import { uint16Array } from '../../uint16Array.js';
+import { uint32Array } from '../../uint32Array.js';
+import { uint8Array } from '../../uint8Array.js';
+import { uint8ClampedArray } from '../../uint8ClampedArray.js';
+import { sparseArray } from '../../sparseArray.js';
+import { arrayToMapMapper, arrayToMapUnmapper } from '../mappers/ArrayToMap.js';
+import { arrayToSetMapper, arrayToSetUnmapper } from '../mappers/ArrayToSet.js';
+import { letrec } from '../../letrec.js';
+import { uniqueArray } from '../../uniqueArray.js';
+import { createDepthIdentifier } from '../helpers/DepthContext.js';
+import { dictionary } from '../../dictionary.js';
+function mapOf(ka, va, maxKeys, size, depthIdentifier) {
+ return uniqueArray(tuple(ka, va), {
+ maxLength: maxKeys,
+ size,
+ comparator: 'SameValueZero',
+ selector: (t) => t[0],
+ depthIdentifier,
+ }).map(arrayToMapMapper, arrayToMapUnmapper);
+}
+function dictOf(ka, va, maxKeys, size, depthIdentifier, withNullPrototype) {
+ return dictionary(ka, va, {
+ maxKeys,
+ noNullPrototype: !withNullPrototype,
+ size,
+ depthIdentifier,
+ });
+}
+function setOf(va, maxKeys, size, depthIdentifier) {
+ return uniqueArray(va, { maxLength: maxKeys, size, comparator: 'SameValueZero', depthIdentifier }).map(arrayToSetMapper, arrayToSetUnmapper);
+}
+function typedArray(constraints) {
+ return oneof(int8Array(constraints), uint8Array(constraints), uint8ClampedArray(constraints), int16Array(constraints), uint16Array(constraints), int32Array(constraints), uint32Array(constraints), float32Array(constraints), float64Array(constraints));
+}
+export function anyArbitraryBuilder(constraints) {
+ const arbitrariesForBase = constraints.values;
+ const depthSize = constraints.depthSize;
+ const depthIdentifier = createDepthIdentifier();
+ const maxDepth = constraints.maxDepth;
+ const maxKeys = constraints.maxKeys;
+ const size = constraints.size;
+ const baseArb = oneof(...arbitrariesForBase, ...(constraints.withBigInt ? [bigInt()] : []), ...(constraints.withDate ? [date()] : []));
+ return letrec((tie) => ({
+ anything: oneof({ maxDepth, depthSize, depthIdentifier }, baseArb, tie('array'), tie('object'), ...(constraints.withMap ? [tie('map')] : []), ...(constraints.withSet ? [tie('set')] : []), ...(constraints.withObjectString ? [tie('anything').map((o) => stringify(o))] : []), ...(constraints.withTypedArray ? [typedArray({ maxLength: maxKeys, size })] : []), ...(constraints.withSparseArray
+ ? [sparseArray(tie('anything'), { maxNumElements: maxKeys, size, depthIdentifier })]
+ : [])),
+ keys: constraints.withObjectString
+ ? oneof({ arbitrary: constraints.key, weight: 10 }, { arbitrary: tie('anything').map((o) => stringify(o)), weight: 1 })
+ : constraints.key,
+ array: array(tie('anything'), { maxLength: maxKeys, size, depthIdentifier }),
+ set: setOf(tie('anything'), maxKeys, size, depthIdentifier),
+ map: oneof(mapOf(tie('keys'), tie('anything'), maxKeys, size, depthIdentifier), mapOf(tie('anything'), tie('anything'), maxKeys, size, depthIdentifier)),
+ object: dictOf(tie('keys'), tie('anything'), maxKeys, size, depthIdentifier, constraints.withNullPrototype),
+ })).anything;
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/BoxedArbitraryBuilder.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/BoxedArbitraryBuilder.js
new file mode 100644
index 0000000000000000000000000000000000000000..35a20fab4e7c402f4e8a3cad884fcc8b9683d335
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/BoxedArbitraryBuilder.js
@@ -0,0 +1,4 @@
+import { unboxedToBoxedMapper, unboxedToBoxedUnmapper } from '../mappers/UnboxedToBoxed.js';
+export function boxedArbitraryBuilder(arb) {
+ return arb.map(unboxedToBoxedMapper, unboxedToBoxedUnmapper);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/CharacterArbitraryBuilder.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/CharacterArbitraryBuilder.js
new file mode 100644
index 0000000000000000000000000000000000000000..06bc95b4db827105a22606f49585507f24a207aa
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/CharacterArbitraryBuilder.js
@@ -0,0 +1,5 @@
+import { integer } from '../../integer.js';
+import { indexToCharStringMapper, indexToCharStringUnmapper } from '../mappers/IndexToCharString.js';
+export function buildCharacterArbitrary(min, max, mapToCode, unmapFromCode) {
+ return integer({ min, max }).map((n) => indexToCharStringMapper(mapToCode(n)), (c) => unmapFromCode(indexToCharStringUnmapper(c)));
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/CharacterRangeArbitraryBuilder.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/CharacterRangeArbitraryBuilder.js
new file mode 100644
index 0000000000000000000000000000000000000000..ce17570a68cfb0e7d1f2d0ad1d6e0a0e35182452
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/CharacterRangeArbitraryBuilder.js
@@ -0,0 +1,61 @@
+import { fullUnicode } from '../../fullUnicode.js';
+import { oneof } from '../../oneof.js';
+import { mapToConstant } from '../../mapToConstant.js';
+import { safeCharCodeAt, safeNumberToString, encodeURIComponent, safeMapGet, safeMapSet } from '../../../utils/globals.js';
+const SMap = Map;
+const safeStringFromCharCode = String.fromCharCode;
+const lowerCaseMapper = { num: 26, build: (v) => safeStringFromCharCode(v + 0x61) };
+const upperCaseMapper = { num: 26, build: (v) => safeStringFromCharCode(v + 0x41) };
+const numericMapper = { num: 10, build: (v) => safeStringFromCharCode(v + 0x30) };
+function percentCharArbMapper(c) {
+ const encoded = encodeURIComponent(c);
+ return c !== encoded ? encoded : `%${safeNumberToString(safeCharCodeAt(c, 0), 16)}`;
+}
+function percentCharArbUnmapper(value) {
+ if (typeof value !== 'string') {
+ throw new Error('Unsupported');
+ }
+ const decoded = decodeURIComponent(value);
+ return decoded;
+}
+const percentCharArb = fullUnicode().map(percentCharArbMapper, percentCharArbUnmapper);
+let lowerAlphaArbitrary = undefined;
+export function getOrCreateLowerAlphaArbitrary() {
+ if (lowerAlphaArbitrary === undefined) {
+ lowerAlphaArbitrary = mapToConstant(lowerCaseMapper);
+ }
+ return lowerAlphaArbitrary;
+}
+let lowerAlphaNumericArbitraries = undefined;
+export function getOrCreateLowerAlphaNumericArbitrary(others) {
+ if (lowerAlphaNumericArbitraries === undefined) {
+ lowerAlphaNumericArbitraries = new SMap();
+ }
+ let match = safeMapGet(lowerAlphaNumericArbitraries, others);
+ if (match === undefined) {
+ match = mapToConstant(lowerCaseMapper, numericMapper, {
+ num: others.length,
+ build: (v) => others[v],
+ });
+ safeMapSet(lowerAlphaNumericArbitraries, others, match);
+ }
+ return match;
+}
+function buildAlphaNumericArbitrary(others) {
+ return mapToConstant(lowerCaseMapper, upperCaseMapper, numericMapper, {
+ num: others.length,
+ build: (v) => others[v],
+ });
+}
+let alphaNumericPercentArbitraries = undefined;
+export function getOrCreateAlphaNumericPercentArbitrary(others) {
+ if (alphaNumericPercentArbitraries === undefined) {
+ alphaNumericPercentArbitraries = new SMap();
+ }
+ let match = safeMapGet(alphaNumericPercentArbitraries, others);
+ if (match === undefined) {
+ match = oneof({ weight: 10, arbitrary: buildAlphaNumericArbitrary(others) }, { weight: 1, arbitrary: percentCharArb });
+ safeMapSet(alphaNumericPercentArbitraries, others, match);
+ }
+ return match;
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/CompareFunctionArbitraryBuilder.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/CompareFunctionArbitraryBuilder.js
new file mode 100644
index 0000000000000000000000000000000000000000..6f2ac5388aeae42c5a6141a9154ea6d21412303c
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/CompareFunctionArbitraryBuilder.js
@@ -0,0 +1,43 @@
+import { escapeForMultilineComments } from '../helpers/TextEscaper.js';
+import { cloneMethod } from '../../../check/symbols.js';
+import { hash } from '../../../utils/hash.js';
+import { stringify } from '../../../utils/stringify.js';
+import { integer } from '../../integer.js';
+import { noShrink } from '../../noShrink.js';
+import { tuple } from '../../tuple.js';
+import { safeJoin } from '../../../utils/globals.js';
+const safeObjectAssign = Object.assign;
+const safeObjectKeys = Object.keys;
+export function buildCompareFunctionArbitrary(cmp) {
+ return tuple(noShrink(integer()), noShrink(integer({ min: 1, max: 0xffffffff }))).map(([seed, hashEnvSize]) => {
+ const producer = () => {
+ const recorded = {};
+ const f = (a, b) => {
+ const reprA = stringify(a);
+ const reprB = stringify(b);
+ const hA = hash(`${seed}${reprA}`) % hashEnvSize;
+ const hB = hash(`${seed}${reprB}`) % hashEnvSize;
+ const val = cmp(hA, hB);
+ recorded[`[${reprA},${reprB}]`] = val;
+ return val;
+ };
+ return safeObjectAssign(f, {
+ toString: () => {
+ const seenValues = safeObjectKeys(recorded)
+ .sort()
+ .map((k) => `${k} => ${stringify(recorded[k])}`)
+ .map((line) => `/* ${escapeForMultilineComments(line)} */`);
+ return `function(a, b) {
+ // With hash and stringify coming from fast-check${seenValues.length !== 0 ? `\n ${safeJoin(seenValues, '\n ')}` : ''}
+ const cmp = ${cmp};
+ const hA = hash('${seed}' + stringify(a)) % ${hashEnvSize};
+ const hB = hash('${seed}' + stringify(b)) % ${hashEnvSize};
+ return cmp(hA, hB);
+}`;
+ },
+ [cloneMethod]: producer,
+ });
+ };
+ return producer();
+ });
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/GeneratorValueBuilder.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/GeneratorValueBuilder.js
new file mode 100644
index 0000000000000000000000000000000000000000..d9a5e0134722bbab6ab4234dfec28a3c9ca47977
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/GeneratorValueBuilder.js
@@ -0,0 +1,38 @@
+import { Value } from '../../../check/arbitrary/definition/Value.js';
+import { cloneMethod } from '../../../check/symbols.js';
+import { safeMap, safePush } from '../../../utils/globals.js';
+import { stringify, toStringMethod } from '../../../utils/stringify.js';
+const safeObjectAssign = Object.assign;
+export function buildGeneratorValue(mrng, biasFactor, computePreBuiltValues, arbitraryCache) {
+ const preBuiltValues = computePreBuiltValues();
+ let localMrng = mrng.clone();
+ const context = { mrng: mrng.clone(), biasFactor, history: [] };
+ const valueFunction = (arb) => {
+ const preBuiltValue = preBuiltValues[context.history.length];
+ if (preBuiltValue !== undefined && preBuiltValue.arb === arb) {
+ const value = preBuiltValue.value;
+ safePush(context.history, { arb, value, context: preBuiltValue.context, mrng: preBuiltValue.mrng });
+ localMrng = preBuiltValue.mrng.clone();
+ return value;
+ }
+ const g = arb.generate(localMrng, biasFactor);
+ safePush(context.history, { arb, value: g.value_, context: g.context, mrng: localMrng.clone() });
+ return g.value;
+ };
+ const memoedValueFunction = (arb, ...args) => {
+ return valueFunction(arbitraryCache(arb, args));
+ };
+ const valueMethods = {
+ values() {
+ return safeMap(context.history, (c) => c.value);
+ },
+ [cloneMethod]() {
+ return buildGeneratorValue(mrng, biasFactor, computePreBuiltValues, arbitraryCache).value;
+ },
+ [toStringMethod]() {
+ return stringify(safeMap(context.history, (c) => c.value));
+ },
+ };
+ const value = safeObjectAssign(memoedValueFunction, valueMethods);
+ return new Value(value, context);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/PaddedNumberArbitraryBuilder.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/PaddedNumberArbitraryBuilder.js
new file mode 100644
index 0000000000000000000000000000000000000000..303227dd8cb314ca1fb3e79978602d8d830f34eb
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/PaddedNumberArbitraryBuilder.js
@@ -0,0 +1,5 @@
+import { integer } from '../../integer.js';
+import { numberToPaddedEightMapper, numberToPaddedEightUnmapper } from '../mappers/NumberToPaddedEight.js';
+export function buildPaddedNumberArbitrary(min, max) {
+ return integer({ min, max }).map(numberToPaddedEightMapper, numberToPaddedEightUnmapper);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/PartialRecordArbitraryBuilder.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/PartialRecordArbitraryBuilder.js
new file mode 100644
index 0000000000000000000000000000000000000000..f6b53cfc1d55c4e3878c51790f0219ef90c4ac14
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/PartialRecordArbitraryBuilder.js
@@ -0,0 +1,23 @@
+import { safeIndexOf, safePush } from '../../../utils/globals.js';
+import { boolean } from '../../boolean.js';
+import { constant } from '../../constant.js';
+import { option } from '../../option.js';
+import { tuple } from '../../tuple.js';
+import { extractEnumerableKeys } from '../helpers/EnumerableKeysExtractor.js';
+import { buildValuesAndSeparateKeysToObjectMapper, buildValuesAndSeparateKeysToObjectUnmapper, } from '../mappers/ValuesAndSeparateKeysToObject.js';
+const noKeyValue = Symbol('no-key');
+export function buildPartialRecordArbitrary(recordModel, requiredKeys, noNullPrototype) {
+ const keys = extractEnumerableKeys(recordModel);
+ const arbs = [];
+ for (let index = 0; index !== keys.length; ++index) {
+ const k = keys[index];
+ const requiredArbitrary = recordModel[k];
+ if (requiredKeys === undefined || safeIndexOf(requiredKeys, k) !== -1) {
+ safePush(arbs, requiredArbitrary);
+ }
+ else {
+ safePush(arbs, option(requiredArbitrary, { nil: noKeyValue }));
+ }
+ }
+ return tuple(tuple(...arbs), noNullPrototype ? constant(false) : boolean()).map(buildValuesAndSeparateKeysToObjectMapper(keys, noKeyValue), buildValuesAndSeparateKeysToObjectUnmapper(keys, noKeyValue));
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/RestrictedIntegerArbitraryBuilder.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/RestrictedIntegerArbitraryBuilder.js
new file mode 100644
index 0000000000000000000000000000000000000000..db3505659dc71191be018678e5df79763e1e18bc
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/RestrictedIntegerArbitraryBuilder.js
@@ -0,0 +1,10 @@
+import { integer } from '../../integer.js';
+import { WithShrinkFromOtherArbitrary } from '../WithShrinkFromOtherArbitrary.js';
+export function restrictedIntegerArbitraryBuilder(min, maxGenerated, max) {
+ const generatorArbitrary = integer({ min, max: maxGenerated });
+ if (maxGenerated === max) {
+ return generatorArbitrary;
+ }
+ const shrinkerArbitrary = integer({ min, max });
+ return new WithShrinkFromOtherArbitrary(generatorArbitrary, shrinkerArbitrary);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/StableArbitraryGeneratorCache.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/StableArbitraryGeneratorCache.js
new file mode 100644
index 0000000000000000000000000000000000000000..fbaf8c0c5d50e56f09d08bba5990ebb800e33c8b
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/StableArbitraryGeneratorCache.js
@@ -0,0 +1,52 @@
+import { Map, safeMapGet, safeMapSet, safePush } from '../../../utils/globals.js';
+const safeArrayIsArray = Array.isArray;
+const safeObjectKeys = Object.keys;
+const safeObjectIs = Object.is;
+export function buildStableArbitraryGeneratorCache(isEqual) {
+ const previousCallsPerBuilder = new Map();
+ return function stableArbitraryGeneratorCache(builder, args) {
+ const entriesForBuilder = safeMapGet(previousCallsPerBuilder, builder);
+ if (entriesForBuilder === undefined) {
+ const newValue = builder(...args);
+ safeMapSet(previousCallsPerBuilder, builder, [{ args, value: newValue }]);
+ return newValue;
+ }
+ const safeEntriesForBuilder = entriesForBuilder;
+ for (const entry of safeEntriesForBuilder) {
+ if (isEqual(args, entry.args)) {
+ return entry.value;
+ }
+ }
+ const newValue = builder(...args);
+ safePush(safeEntriesForBuilder, { args, value: newValue });
+ return newValue;
+ };
+}
+export function naiveIsEqual(v1, v2) {
+ if (v1 !== null && typeof v1 === 'object' && v2 !== null && typeof v2 === 'object') {
+ if (safeArrayIsArray(v1)) {
+ if (!safeArrayIsArray(v2))
+ return false;
+ if (v1.length !== v2.length)
+ return false;
+ }
+ else if (safeArrayIsArray(v2)) {
+ return false;
+ }
+ if (safeObjectKeys(v1).length !== safeObjectKeys(v2).length) {
+ return false;
+ }
+ for (const index in v1) {
+ if (!(index in v2)) {
+ return false;
+ }
+ if (!naiveIsEqual(v1[index], v2[index])) {
+ return false;
+ }
+ }
+ return true;
+ }
+ else {
+ return safeObjectIs(v1, v2);
+ }
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/StringifiedNatArbitraryBuilder.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/StringifiedNatArbitraryBuilder.js
new file mode 100644
index 0000000000000000000000000000000000000000..c3d659a06059938f4cef1a1c8c0662943ff58439
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/StringifiedNatArbitraryBuilder.js
@@ -0,0 +1,7 @@
+import { constantFrom } from '../../constantFrom.js';
+import { nat } from '../../nat.js';
+import { tuple } from '../../tuple.js';
+import { natToStringifiedNatMapper, natToStringifiedNatUnmapper } from '../mappers/NatToStringifiedNat.js';
+export function buildStringifiedNatArbitrary(maxValue) {
+ return tuple(constantFrom('dec', 'oct', 'hex'), nat(maxValue)).map(natToStringifiedNatMapper, natToStringifiedNatUnmapper);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/TypedIntArrayArbitraryBuilder.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/TypedIntArrayArbitraryBuilder.js
new file mode 100644
index 0000000000000000000000000000000000000000..516b68fd20da2eae57e7ff950403330b00ffbb64
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/TypedIntArrayArbitraryBuilder.js
@@ -0,0 +1,30 @@
+var __rest = (this && this.__rest) || function (s, e) {
+ var t = {};
+ for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+ t[p] = s[p];
+ if (s != null && typeof Object.getOwnPropertySymbols === "function")
+ for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+ if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+ t[p[i]] = s[p[i]];
+ }
+ return t;
+};
+import { array } from '../../array.js';
+export function typedIntArrayArbitraryArbitraryBuilder(constraints, defaultMin, defaultMax, TypedArrayClass, arbitraryBuilder) {
+ const generatorName = TypedArrayClass.name;
+ const { min = defaultMin, max = defaultMax } = constraints, arrayConstraints = __rest(constraints, ["min", "max"]);
+ if (min > max) {
+ throw new Error(`Invalid range passed to ${generatorName}: min must be lower than or equal to max`);
+ }
+ if (min < defaultMin) {
+ throw new Error(`Invalid min value passed to ${generatorName}: min must be greater than or equal to ${defaultMin}`);
+ }
+ if (max > defaultMax) {
+ throw new Error(`Invalid max value passed to ${generatorName}: max must be lower than or equal to ${defaultMax}`);
+ }
+ return array(arbitraryBuilder({ min, max }), arrayConstraints).map((data) => TypedArrayClass.from(data), (value) => {
+ if (!(value instanceof TypedArrayClass))
+ throw new Error('Invalid type');
+ return [...value];
+ });
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/UriPathArbitraryBuilder.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/UriPathArbitraryBuilder.js
new file mode 100644
index 0000000000000000000000000000000000000000..dd7d3c39b40d2bc455fa722b153c30fffd6908ac
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/UriPathArbitraryBuilder.js
@@ -0,0 +1,28 @@
+import { webSegment } from '../../webSegment.js';
+import { array } from '../../array.js';
+import { segmentsToPathMapper, segmentsToPathUnmapper } from '../mappers/SegmentsToPath.js';
+import { oneof } from '../../oneof.js';
+function sqrtSize(size) {
+ switch (size) {
+ case 'xsmall':
+ return ['xsmall', 'xsmall'];
+ case 'small':
+ return ['small', 'xsmall'];
+ case 'medium':
+ return ['small', 'small'];
+ case 'large':
+ return ['medium', 'small'];
+ case 'xlarge':
+ return ['medium', 'medium'];
+ }
+}
+function buildUriPathArbitraryInternal(segmentSize, numSegmentSize) {
+ return array(webSegment({ size: segmentSize }), { size: numSegmentSize }).map(segmentsToPathMapper, segmentsToPathUnmapper);
+}
+export function buildUriPathArbitrary(resolvedSize) {
+ const [segmentSize, numSegmentSize] = sqrtSize(resolvedSize);
+ if (segmentSize === numSegmentSize) {
+ return buildUriPathArbitraryInternal(segmentSize, numSegmentSize);
+ }
+ return oneof(buildUriPathArbitraryInternal(segmentSize, numSegmentSize), buildUriPathArbitraryInternal(numSegmentSize, segmentSize));
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/UriQueryOrFragmentArbitraryBuilder.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/UriQueryOrFragmentArbitraryBuilder.js
new file mode 100644
index 0000000000000000000000000000000000000000..dcf84caaf01171f5e14b895d61bb68ef974a21dd
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/UriQueryOrFragmentArbitraryBuilder.js
@@ -0,0 +1,5 @@
+import { getOrCreateAlphaNumericPercentArbitrary } from './CharacterRangeArbitraryBuilder.js';
+import { string } from '../../string.js';
+export function buildUriQueryOrFragmentArbitrary(size) {
+ return string({ unit: getOrCreateAlphaNumericPercentArbitrary("-._~!$&'()*+,;=:@/?"), size });
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/data/GraphemeRanges.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/data/GraphemeRanges.js
new file mode 100644
index 0000000000000000000000000000000000000000..424b47aff0059d0f2a3d2246236f9f9f9e340a0f
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/data/GraphemeRanges.js
@@ -0,0 +1,985 @@
+export const asciiAlphabetRanges = [[0x00, 0x7f]];
+export const fullAlphabetRanges = [
+ [0x0000, 0xd7ff],
+ [0xe000, 0x10ffff],
+];
+export const autonomousGraphemeRanges = [
+ [0x20, 0x7e],
+ [0xa0, 0xac],
+ [0xae, 0x2ff],
+ [0x370, 0x377],
+ [0x37a, 0x37f],
+ [0x384, 0x38a],
+ [0x38c],
+ [0x38e, 0x3a1],
+ [0x3a3, 0x482],
+ [0x48a, 0x52f],
+ [0x531, 0x556],
+ [0x559, 0x58a],
+ [0x58d, 0x58f],
+ [0x5be],
+ [0x5c0],
+ [0x5c3],
+ [0x5c6],
+ [0x5d0, 0x5ea],
+ [0x5ef, 0x5f4],
+ [0x606, 0x60f],
+ [0x61b],
+ [0x61d, 0x64a],
+ [0x660, 0x66f],
+ [0x671, 0x6d5],
+ [0x6de],
+ [0x6e5, 0x6e6],
+ [0x6e9],
+ [0x6ee, 0x70d],
+ [0x710],
+ [0x712, 0x72f],
+ [0x74d, 0x7a5],
+ [0x7b1],
+ [0x7c0, 0x7ea],
+ [0x7f4, 0x7fa],
+ [0x7fe, 0x815],
+ [0x81a],
+ [0x824],
+ [0x828],
+ [0x830, 0x83e],
+ [0x840, 0x858],
+ [0x85e],
+ [0x860, 0x86a],
+ [0x870, 0x88e],
+ [0x8a0, 0x8c9],
+ [0x904, 0x939],
+ [0x93d],
+ [0x950],
+ [0x958, 0x961],
+ [0x964, 0x980],
+ [0x985, 0x98c],
+ [0x98f, 0x990],
+ [0x993, 0x9a8],
+ [0x9aa, 0x9b0],
+ [0x9b2],
+ [0x9b6, 0x9b9],
+ [0x9bd],
+ [0x9ce],
+ [0x9dc, 0x9dd],
+ [0x9df, 0x9e1],
+ [0x9e6, 0x9fd],
+ [0xa05, 0xa0a],
+ [0xa0f, 0xa10],
+ [0xa13, 0xa28],
+ [0xa2a, 0xa30],
+ [0xa32, 0xa33],
+ [0xa35, 0xa36],
+ [0xa38, 0xa39],
+ [0xa59, 0xa5c],
+ [0xa5e],
+ [0xa66, 0xa6f],
+ [0xa72, 0xa74],
+ [0xa76],
+ [0xa85, 0xa8d],
+ [0xa8f, 0xa91],
+ [0xa93, 0xaa8],
+ [0xaaa, 0xab0],
+ [0xab2, 0xab3],
+ [0xab5, 0xab9],
+ [0xabd],
+ [0xad0],
+ [0xae0, 0xae1],
+ [0xae6, 0xaf1],
+ [0xaf9],
+ [0xb05, 0xb0c],
+ [0xb0f, 0xb10],
+ [0xb13, 0xb28],
+ [0xb2a, 0xb30],
+ [0xb32, 0xb33],
+ [0xb35, 0xb39],
+ [0xb3d],
+ [0xb5c, 0xb5d],
+ [0xb5f, 0xb61],
+ [0xb66, 0xb77],
+ [0xb83],
+ [0xb85, 0xb8a],
+ [0xb8e, 0xb90],
+ [0xb92, 0xb95],
+ [0xb99, 0xb9a],
+ [0xb9c],
+ [0xb9e, 0xb9f],
+ [0xba3, 0xba4],
+ [0xba8, 0xbaa],
+ [0xbae, 0xbb9],
+ [0xbd0],
+ [0xbe6, 0xbfa],
+ [0xc05, 0xc0c],
+ [0xc0e, 0xc10],
+ [0xc12, 0xc28],
+ [0xc2a, 0xc39],
+ [0xc3d],
+ [0xc58, 0xc5a],
+ [0xc5d],
+ [0xc60, 0xc61],
+ [0xc66, 0xc6f],
+ [0xc77, 0xc80],
+ [0xc84, 0xc8c],
+ [0xc8e, 0xc90],
+ [0xc92, 0xca8],
+ [0xcaa, 0xcb3],
+ [0xcb5, 0xcb9],
+ [0xcbd],
+ [0xcdd, 0xcde],
+ [0xce0, 0xce1],
+ [0xce6, 0xcef],
+ [0xcf1, 0xcf2],
+ [0xd04, 0xd0c],
+ [0xd0e, 0xd10],
+ [0xd12, 0xd3a],
+ [0xd3d],
+ [0xd4f],
+ [0xd54, 0xd56],
+ [0xd58, 0xd61],
+ [0xd66, 0xd7f],
+ [0xd85, 0xd96],
+ [0xd9a, 0xdb1],
+ [0xdb3, 0xdbb],
+ [0xdbd],
+ [0xdc0, 0xdc6],
+ [0xde6, 0xdef],
+ [0xdf4],
+ [0xe01, 0xe30],
+ [0xe32],
+ [0xe3f, 0xe46],
+ [0xe4f, 0xe5b],
+ [0xe81, 0xe82],
+ [0xe84],
+ [0xe86, 0xe8a],
+ [0xe8c, 0xea3],
+ [0xea5],
+ [0xea7, 0xeb0],
+ [0xeb2],
+ [0xebd],
+ [0xec0, 0xec4],
+ [0xec6],
+ [0xed0, 0xed9],
+ [0xedc, 0xedf],
+ [0xf00, 0xf17],
+ [0xf1a, 0xf34],
+ [0xf36],
+ [0xf38],
+ [0xf3a, 0xf3d],
+ [0xf40, 0xf47],
+ [0xf49, 0xf6c],
+ [0xf85],
+ [0xf88, 0xf8c],
+ [0xfbe, 0xfc5],
+ [0xfc7, 0xfcc],
+ [0xfce, 0xfda],
+ [0x1000, 0x102a],
+ [0x103f, 0x1055],
+ [0x105a, 0x105d],
+ [0x1061],
+ [0x1065, 0x1066],
+ [0x106e, 0x1070],
+ [0x1075, 0x1081],
+ [0x108e],
+ [0x1090, 0x1099],
+ [0x109e, 0x10c5],
+ [0x10c7],
+ [0x10cd],
+ [0x10d0, 0x10ff],
+ [0x1200, 0x1248],
+ [0x124a, 0x124d],
+ [0x1250, 0x1256],
+ [0x1258],
+ [0x125a, 0x125d],
+ [0x1260, 0x1288],
+ [0x128a, 0x128d],
+ [0x1290, 0x12b0],
+ [0x12b2, 0x12b5],
+ [0x12b8, 0x12be],
+ [0x12c0],
+ [0x12c2, 0x12c5],
+ [0x12c8, 0x12d6],
+ [0x12d8, 0x1310],
+ [0x1312, 0x1315],
+ [0x1318, 0x135a],
+ [0x1360, 0x137c],
+ [0x1380, 0x1399],
+ [0x13a0, 0x13f5],
+ [0x13f8, 0x13fd],
+ [0x1400, 0x169c],
+ [0x16a0, 0x16f8],
+ [0x1700, 0x1711],
+ [0x171f, 0x1731],
+ [0x1735, 0x1736],
+ [0x1740, 0x1751],
+ [0x1760, 0x176c],
+ [0x176e, 0x1770],
+ [0x1780, 0x17b3],
+ [0x17d4, 0x17dc],
+ [0x17e0, 0x17e9],
+ [0x17f0, 0x17f9],
+ [0x1800, 0x180a],
+ [0x1810, 0x1819],
+ [0x1820, 0x1878],
+ [0x1880, 0x1884],
+ [0x1887, 0x18a8],
+ [0x18aa],
+ [0x18b0, 0x18f5],
+ [0x1900, 0x191e],
+ [0x1940],
+ [0x1944, 0x196d],
+ [0x1970, 0x1974],
+ [0x1980, 0x19ab],
+ [0x19b0, 0x19c9],
+ [0x19d0, 0x19da],
+ [0x19de, 0x1a16],
+ [0x1a1e, 0x1a54],
+ [0x1a80, 0x1a89],
+ [0x1a90, 0x1a99],
+ [0x1aa0, 0x1aad],
+ [0x1b05, 0x1b33],
+ [0x1b45, 0x1b4c],
+ [0x1b50, 0x1b6a],
+ [0x1b74, 0x1b7e],
+ [0x1b83, 0x1ba0],
+ [0x1bae, 0x1be5],
+ [0x1bfc, 0x1c23],
+ [0x1c3b, 0x1c49],
+ [0x1c4d, 0x1c88],
+ [0x1c90, 0x1cba],
+ [0x1cbd, 0x1cc7],
+ [0x1cd3],
+ [0x1ce9, 0x1cec],
+ [0x1cee, 0x1cf3],
+ [0x1cf5, 0x1cf6],
+ [0x1cfa],
+ [0x1d00, 0x1dbf],
+ [0x1e00, 0x1f15],
+ [0x1f18, 0x1f1d],
+ [0x1f20, 0x1f45],
+ [0x1f48, 0x1f4d],
+ [0x1f50, 0x1f57],
+ [0x1f59],
+ [0x1f5b],
+ [0x1f5d],
+ [0x1f5f, 0x1f7d],
+ [0x1f80, 0x1fb4],
+ [0x1fb6, 0x1fc4],
+ [0x1fc6, 0x1fd3],
+ [0x1fd6, 0x1fdb],
+ [0x1fdd, 0x1fef],
+ [0x1ff2, 0x1ff4],
+ [0x1ff6, 0x1ffe],
+ [0x2000, 0x200a],
+ [0x2010, 0x2029],
+ [0x202f, 0x205f],
+ [0x2070, 0x2071],
+ [0x2074, 0x208e],
+ [0x2090, 0x209c],
+ [0x20a0, 0x20c0],
+ [0x2100, 0x218b],
+ [0x2190, 0x2426],
+ [0x2440, 0x244a],
+ [0x2460, 0x2b73],
+ [0x2b76, 0x2b95],
+ [0x2b97, 0x2cee],
+ [0x2cf2, 0x2cf3],
+ [0x2cf9, 0x2d25],
+ [0x2d27],
+ [0x2d2d],
+ [0x2d30, 0x2d67],
+ [0x2d6f, 0x2d70],
+ [0x2d80, 0x2d96],
+ [0x2da0, 0x2da6],
+ [0x2da8, 0x2dae],
+ [0x2db0, 0x2db6],
+ [0x2db8, 0x2dbe],
+ [0x2dc0, 0x2dc6],
+ [0x2dc8, 0x2dce],
+ [0x2dd0, 0x2dd6],
+ [0x2dd8, 0x2dde],
+ [0x2e00, 0x2e5d],
+ [0x2e80, 0x2e99],
+ [0x2e9b, 0x2ef3],
+ [0x2f00, 0x2fd5],
+ [0x2ff0, 0x3029],
+ [0x3030, 0x303f],
+ [0x3041, 0x3096],
+ [0x309b, 0x30ff],
+ [0x3105, 0x312f],
+ [0x3131, 0x318e],
+ [0x3190, 0x31e3],
+ [0x31ef, 0x321e],
+ [0x3220, 0x3400],
+ [0x4dbf, 0x4e00],
+ [0x9fff, 0xa48c],
+ [0xa490, 0xa4c6],
+ [0xa4d0, 0xa62b],
+ [0xa640, 0xa66e],
+ [0xa673],
+ [0xa67e, 0xa69d],
+ [0xa6a0, 0xa6ef],
+ [0xa6f2, 0xa6f7],
+ [0xa700, 0xa7ca],
+ [0xa7d0, 0xa7d1],
+ [0xa7d3],
+ [0xa7d5, 0xa7d9],
+ [0xa7f2, 0xa801],
+ [0xa803, 0xa805],
+ [0xa807, 0xa80a],
+ [0xa80c, 0xa822],
+ [0xa828, 0xa82b],
+ [0xa830, 0xa839],
+ [0xa840, 0xa877],
+ [0xa882, 0xa8b3],
+ [0xa8ce, 0xa8d9],
+ [0xa8f2, 0xa8fe],
+ [0xa900, 0xa925],
+ [0xa92e, 0xa946],
+ [0xa95f],
+ [0xa984, 0xa9b2],
+ [0xa9c1, 0xa9cd],
+ [0xa9cf, 0xa9d9],
+ [0xa9de, 0xa9e4],
+ [0xa9e6, 0xa9fe],
+ [0xaa00, 0xaa28],
+ [0xaa40, 0xaa42],
+ [0xaa44, 0xaa4b],
+ [0xaa50, 0xaa59],
+ [0xaa5c, 0xaa7a],
+ [0xaa7e, 0xaaaf],
+ [0xaab1],
+ [0xaab5, 0xaab6],
+ [0xaab9, 0xaabd],
+ [0xaac0],
+ [0xaac2],
+ [0xaadb, 0xaaea],
+ [0xaaf0, 0xaaf4],
+ [0xab01, 0xab06],
+ [0xab09, 0xab0e],
+ [0xab11, 0xab16],
+ [0xab20, 0xab26],
+ [0xab28, 0xab2e],
+ [0xab30, 0xab6b],
+ [0xab70, 0xabe2],
+ [0xabeb],
+ [0xabf0, 0xabf9],
+ [0xac00],
+ [0xd7a3],
+ [0xf900, 0xfa6d],
+ [0xfa70, 0xfad9],
+ [0xfb00, 0xfb06],
+ [0xfb13, 0xfb17],
+ [0xfb1d],
+ [0xfb1f, 0xfb36],
+ [0xfb38, 0xfb3c],
+ [0xfb3e],
+ [0xfb40, 0xfb41],
+ [0xfb43, 0xfb44],
+ [0xfb46, 0xfbc2],
+ [0xfbd3, 0xfd8f],
+ [0xfd92, 0xfdc7],
+ [0xfdcf],
+ [0xfdf0, 0xfdff],
+ [0xfe10, 0xfe19],
+ [0xfe30, 0xfe52],
+ [0xfe54, 0xfe66],
+ [0xfe68, 0xfe6b],
+ [0xfe70, 0xfe74],
+ [0xfe76, 0xfefc],
+ [0xff01, 0xff9d],
+ [0xffa0, 0xffbe],
+ [0xffc2, 0xffc7],
+ [0xffca, 0xffcf],
+ [0xffd2, 0xffd7],
+ [0xffda, 0xffdc],
+ [0xffe0, 0xffe6],
+ [0xffe8, 0xffee],
+ [0xfffc, 0xfffd],
+ [0x10000, 0x1000b],
+ [0x1000d, 0x10026],
+ [0x10028, 0x1003a],
+ [0x1003c, 0x1003d],
+ [0x1003f, 0x1004d],
+ [0x10050, 0x1005d],
+ [0x10080, 0x100fa],
+ [0x10100, 0x10102],
+ [0x10107, 0x10133],
+ [0x10137, 0x1018e],
+ [0x10190, 0x1019c],
+ [0x101a0],
+ [0x101d0, 0x101fc],
+ [0x10280, 0x1029c],
+ [0x102a0, 0x102d0],
+ [0x102e1, 0x102fb],
+ [0x10300, 0x10323],
+ [0x1032d, 0x1034a],
+ [0x10350, 0x10375],
+ [0x10380, 0x1039d],
+ [0x1039f, 0x103c3],
+ [0x103c8, 0x103d5],
+ [0x10400, 0x1049d],
+ [0x104a0, 0x104a9],
+ [0x104b0, 0x104d3],
+ [0x104d8, 0x104fb],
+ [0x10500, 0x10527],
+ [0x10530, 0x10563],
+ [0x1056f, 0x1057a],
+ [0x1057c, 0x1058a],
+ [0x1058c, 0x10592],
+ [0x10594, 0x10595],
+ [0x10597, 0x105a1],
+ [0x105a3, 0x105b1],
+ [0x105b3, 0x105b9],
+ [0x105bb, 0x105bc],
+ [0x10600, 0x10736],
+ [0x10740, 0x10755],
+ [0x10760, 0x10767],
+ [0x10780, 0x10785],
+ [0x10787, 0x107b0],
+ [0x107b2, 0x107ba],
+ [0x10800, 0x10805],
+ [0x10808],
+ [0x1080a, 0x10835],
+ [0x10837, 0x10838],
+ [0x1083c],
+ [0x1083f, 0x10855],
+ [0x10857, 0x1089e],
+ [0x108a7, 0x108af],
+ [0x108e0, 0x108f2],
+ [0x108f4, 0x108f5],
+ [0x108fb, 0x1091b],
+ [0x1091f, 0x10939],
+ [0x1093f],
+ [0x10980, 0x109b7],
+ [0x109bc, 0x109cf],
+ [0x109d2, 0x10a00],
+ [0x10a10, 0x10a13],
+ [0x10a15, 0x10a17],
+ [0x10a19, 0x10a35],
+ [0x10a40, 0x10a48],
+ [0x10a50, 0x10a58],
+ [0x10a60, 0x10a9f],
+ [0x10ac0, 0x10ae4],
+ [0x10aeb, 0x10af6],
+ [0x10b00, 0x10b35],
+ [0x10b39, 0x10b55],
+ [0x10b58, 0x10b72],
+ [0x10b78, 0x10b91],
+ [0x10b99, 0x10b9c],
+ [0x10ba9, 0x10baf],
+ [0x10c00, 0x10c48],
+ [0x10c80, 0x10cb2],
+ [0x10cc0, 0x10cf2],
+ [0x10cfa, 0x10d23],
+ [0x10d30, 0x10d39],
+ [0x10e60, 0x10e7e],
+ [0x10e80, 0x10ea9],
+ [0x10ead],
+ [0x10eb0, 0x10eb1],
+ [0x10f00, 0x10f27],
+ [0x10f30, 0x10f45],
+ [0x10f51, 0x10f59],
+ [0x10f70, 0x10f81],
+ [0x10f86, 0x10f89],
+ [0x10fb0, 0x10fcb],
+ [0x10fe0, 0x10ff6],
+ [0x11003, 0x11037],
+ [0x11047, 0x1104d],
+ [0x11052, 0x1106f],
+ [0x11071, 0x11072],
+ [0x11075],
+ [0x11083, 0x110af],
+ [0x110bb, 0x110bc],
+ [0x110be, 0x110c1],
+ [0x110d0, 0x110e8],
+ [0x110f0, 0x110f9],
+ [0x11103, 0x11126],
+ [0x11136, 0x11144],
+ [0x11147],
+ [0x11150, 0x11172],
+ [0x11174, 0x11176],
+ [0x11183, 0x111b2],
+ [0x111c1],
+ [0x111c4, 0x111c8],
+ [0x111cd],
+ [0x111d0, 0x111df],
+ [0x111e1, 0x111f4],
+ [0x11200, 0x11211],
+ [0x11213, 0x1122b],
+ [0x11238, 0x1123d],
+ [0x1123f, 0x11240],
+ [0x11280, 0x11286],
+ [0x11288],
+ [0x1128a, 0x1128d],
+ [0x1128f, 0x1129d],
+ [0x1129f, 0x112a9],
+ [0x112b0, 0x112de],
+ [0x112f0, 0x112f9],
+ [0x11305, 0x1130c],
+ [0x1130f, 0x11310],
+ [0x11313, 0x11328],
+ [0x1132a, 0x11330],
+ [0x11332, 0x11333],
+ [0x11335, 0x11339],
+ [0x1133d],
+ [0x11350],
+ [0x1135d, 0x11361],
+ [0x11400, 0x11434],
+ [0x11447, 0x1145b],
+ [0x1145d],
+ [0x1145f, 0x11461],
+ [0x11480, 0x114af],
+ [0x114c4, 0x114c7],
+ [0x114d0, 0x114d9],
+ [0x11580, 0x115ae],
+ [0x115c1, 0x115db],
+ [0x11600, 0x1162f],
+ [0x11641, 0x11644],
+ [0x11650, 0x11659],
+ [0x11660, 0x1166c],
+ [0x11680, 0x116aa],
+ [0x116b8, 0x116b9],
+ [0x116c0, 0x116c9],
+ [0x11700, 0x1171a],
+ [0x11730, 0x11746],
+ [0x11800, 0x1182b],
+ [0x1183b],
+ [0x118a0, 0x118f2],
+ [0x118ff, 0x11906],
+ [0x11909],
+ [0x1190c, 0x11913],
+ [0x11915, 0x11916],
+ [0x11918, 0x1192f],
+ [0x11944, 0x11946],
+ [0x11950, 0x11959],
+ [0x119a0, 0x119a7],
+ [0x119aa, 0x119d0],
+ [0x119e1, 0x119e3],
+ [0x11a00],
+ [0x11a0b, 0x11a32],
+ [0x11a3f, 0x11a46],
+ [0x11a50],
+ [0x11a5c, 0x11a83],
+ [0x11a9a, 0x11aa2],
+ [0x11ab0, 0x11af8],
+ [0x11b00, 0x11b09],
+ [0x11c00, 0x11c08],
+ [0x11c0a, 0x11c2e],
+ [0x11c40, 0x11c45],
+ [0x11c50, 0x11c6c],
+ [0x11c70, 0x11c8f],
+ [0x11d00, 0x11d06],
+ [0x11d08, 0x11d09],
+ [0x11d0b, 0x11d30],
+ [0x11d50, 0x11d59],
+ [0x11d60, 0x11d65],
+ [0x11d67, 0x11d68],
+ [0x11d6a, 0x11d89],
+ [0x11d98],
+ [0x11da0, 0x11da9],
+ [0x11ee0, 0x11ef2],
+ [0x11ef7, 0x11ef8],
+ [0x11f04, 0x11f10],
+ [0x11f12, 0x11f33],
+ [0x11f43, 0x11f59],
+ [0x11fb0],
+ [0x11fc0, 0x11ff1],
+ [0x11fff, 0x12399],
+ [0x12400, 0x1246e],
+ [0x12470, 0x12474],
+ [0x12480, 0x12543],
+ [0x12f90, 0x12ff2],
+ [0x13000, 0x1342f],
+ [0x13441, 0x13446],
+ [0x14400, 0x14646],
+ [0x16800, 0x16a38],
+ [0x16a40, 0x16a5e],
+ [0x16a60, 0x16a69],
+ [0x16a6e, 0x16abe],
+ [0x16ac0, 0x16ac9],
+ [0x16ad0, 0x16aed],
+ [0x16af5],
+ [0x16b00, 0x16b2f],
+ [0x16b37, 0x16b45],
+ [0x16b50, 0x16b59],
+ [0x16b5b, 0x16b61],
+ [0x16b63, 0x16b77],
+ [0x16b7d, 0x16b8f],
+ [0x16e40, 0x16e9a],
+ [0x16f00, 0x16f4a],
+ [0x16f50],
+ [0x16f93, 0x16f9f],
+ [0x16fe0, 0x16fe3],
+ [0x17000],
+ [0x187f7],
+ [0x18800, 0x18cd5],
+ [0x18d00],
+ [0x18d08],
+ [0x1aff0, 0x1aff3],
+ [0x1aff5, 0x1affb],
+ [0x1affd, 0x1affe],
+ [0x1b000, 0x1b122],
+ [0x1b132],
+ [0x1b150, 0x1b152],
+ [0x1b155],
+ [0x1b164, 0x1b167],
+ [0x1b170, 0x1b2fb],
+ [0x1bc00, 0x1bc6a],
+ [0x1bc70, 0x1bc7c],
+ [0x1bc80, 0x1bc88],
+ [0x1bc90, 0x1bc99],
+ [0x1bc9c],
+ [0x1bc9f],
+ [0x1cf50, 0x1cfc3],
+ [0x1d000, 0x1d0f5],
+ [0x1d100, 0x1d126],
+ [0x1d129, 0x1d164],
+ [0x1d16a, 0x1d16c],
+ [0x1d183, 0x1d184],
+ [0x1d18c, 0x1d1a9],
+ [0x1d1ae, 0x1d1ea],
+ [0x1d200, 0x1d241],
+ [0x1d245],
+ [0x1d2c0, 0x1d2d3],
+ [0x1d2e0, 0x1d2f3],
+ [0x1d300, 0x1d356],
+ [0x1d360, 0x1d378],
+ [0x1d400, 0x1d454],
+ [0x1d456, 0x1d49c],
+ [0x1d49e, 0x1d49f],
+ [0x1d4a2],
+ [0x1d4a5, 0x1d4a6],
+ [0x1d4a9, 0x1d4ac],
+ [0x1d4ae, 0x1d4b9],
+ [0x1d4bb],
+ [0x1d4bd, 0x1d4c3],
+ [0x1d4c5, 0x1d505],
+ [0x1d507, 0x1d50a],
+ [0x1d50d, 0x1d514],
+ [0x1d516, 0x1d51c],
+ [0x1d51e, 0x1d539],
+ [0x1d53b, 0x1d53e],
+ [0x1d540, 0x1d544],
+ [0x1d546],
+ [0x1d54a, 0x1d550],
+ [0x1d552, 0x1d6a5],
+ [0x1d6a8, 0x1d7cb],
+ [0x1d7ce, 0x1d9ff],
+ [0x1da37, 0x1da3a],
+ [0x1da6d, 0x1da74],
+ [0x1da76, 0x1da83],
+ [0x1da85, 0x1da8b],
+ [0x1df00, 0x1df1e],
+ [0x1df25, 0x1df2a],
+ [0x1e030, 0x1e06d],
+ [0x1e100, 0x1e12c],
+ [0x1e137, 0x1e13d],
+ [0x1e140, 0x1e149],
+ [0x1e14e, 0x1e14f],
+ [0x1e290, 0x1e2ad],
+ [0x1e2c0, 0x1e2eb],
+ [0x1e2f0, 0x1e2f9],
+ [0x1e2ff],
+ [0x1e4d0, 0x1e4eb],
+ [0x1e4f0, 0x1e4f9],
+ [0x1e7e0, 0x1e7e6],
+ [0x1e7e8, 0x1e7eb],
+ [0x1e7ed, 0x1e7ee],
+ [0x1e7f0, 0x1e7fe],
+ [0x1e800, 0x1e8c4],
+ [0x1e8c7, 0x1e8cf],
+ [0x1e900, 0x1e943],
+ [0x1e94b],
+ [0x1e950, 0x1e959],
+ [0x1e95e, 0x1e95f],
+ [0x1ec71, 0x1ecb4],
+ [0x1ed01, 0x1ed3d],
+ [0x1ee00, 0x1ee03],
+ [0x1ee05, 0x1ee1f],
+ [0x1ee21, 0x1ee22],
+ [0x1ee24],
+ [0x1ee27],
+ [0x1ee29, 0x1ee32],
+ [0x1ee34, 0x1ee37],
+ [0x1ee39],
+ [0x1ee3b],
+ [0x1ee42],
+ [0x1ee47],
+ [0x1ee49],
+ [0x1ee4b],
+ [0x1ee4d, 0x1ee4f],
+ [0x1ee51, 0x1ee52],
+ [0x1ee54],
+ [0x1ee57],
+ [0x1ee59],
+ [0x1ee5b],
+ [0x1ee5d],
+ [0x1ee5f],
+ [0x1ee61, 0x1ee62],
+ [0x1ee64],
+ [0x1ee67, 0x1ee6a],
+ [0x1ee6c, 0x1ee72],
+ [0x1ee74, 0x1ee77],
+ [0x1ee79, 0x1ee7c],
+ [0x1ee7e],
+ [0x1ee80, 0x1ee89],
+ [0x1ee8b, 0x1ee9b],
+ [0x1eea1, 0x1eea3],
+ [0x1eea5, 0x1eea9],
+ [0x1eeab, 0x1eebb],
+ [0x1eef0, 0x1eef1],
+ [0x1f000, 0x1f02b],
+ [0x1f030, 0x1f093],
+ [0x1f0a0, 0x1f0ae],
+ [0x1f0b1, 0x1f0bf],
+ [0x1f0c1, 0x1f0cf],
+ [0x1f0d1, 0x1f0f5],
+ [0x1f100, 0x1f1ad],
+ [0x1f200, 0x1f202],
+ [0x1f210, 0x1f23b],
+ [0x1f240, 0x1f248],
+ [0x1f250, 0x1f251],
+ [0x1f260, 0x1f265],
+ [0x1f300, 0x1f3fa],
+ [0x1f400, 0x1f6d7],
+ [0x1f6dc, 0x1f6ec],
+ [0x1f6f0, 0x1f6fc],
+ [0x1f700, 0x1f776],
+ [0x1f77b, 0x1f7d9],
+ [0x1f7e0, 0x1f7eb],
+ [0x1f7f0],
+ [0x1f800, 0x1f80b],
+ [0x1f810, 0x1f847],
+ [0x1f850, 0x1f859],
+ [0x1f860, 0x1f887],
+ [0x1f890, 0x1f8ad],
+ [0x1f8b0, 0x1f8b1],
+ [0x1f900, 0x1fa53],
+ [0x1fa60, 0x1fa6d],
+ [0x1fa70, 0x1fa7c],
+ [0x1fa80, 0x1fa88],
+ [0x1fa90, 0x1fabd],
+ [0x1fabf, 0x1fac5],
+ [0x1face, 0x1fadb],
+ [0x1fae0, 0x1fae8],
+ [0x1faf0, 0x1faf8],
+ [0x1fb00, 0x1fb92],
+ [0x1fb94, 0x1fbca],
+ [0x1fbf0, 0x1fbf9],
+ [0x20000],
+ [0x2a6df],
+ [0x2a700],
+ [0x2b739],
+ [0x2b740],
+ [0x2b81d],
+ [0x2b820],
+ [0x2cea1],
+ [0x2ceb0],
+ [0x2ebe0],
+ [0x2ebf0],
+ [0x2ee5d],
+ [0x2f800, 0x2fa1d],
+ [0x30000],
+ [0x3134a],
+ [0x31350],
+ [0x323af],
+];
+export const autonomousDecomposableGraphemeRanges = [
+ [0xc0, 0xc5],
+ [0xc7, 0xcf],
+ [0xd1, 0xd6],
+ [0xd9, 0xdd],
+ [0xe0, 0xe5],
+ [0xe7, 0xef],
+ [0xf1, 0xf6],
+ [0xf9, 0xfd],
+ [0xff, 0x10f],
+ [0x112, 0x125],
+ [0x128, 0x130],
+ [0x134, 0x137],
+ [0x139, 0x13e],
+ [0x143, 0x148],
+ [0x14c, 0x151],
+ [0x154, 0x165],
+ [0x168, 0x17e],
+ [0x1a0, 0x1a1],
+ [0x1af, 0x1b0],
+ [0x1cd, 0x1dc],
+ [0x1de, 0x1e3],
+ [0x1e6, 0x1f0],
+ [0x1f4, 0x1f5],
+ [0x1f8, 0x21b],
+ [0x21e, 0x21f],
+ [0x226, 0x233],
+ [0x385, 0x386],
+ [0x388, 0x38a],
+ [0x38c],
+ [0x38e, 0x390],
+ [0x3aa, 0x3b0],
+ [0x3ca, 0x3ce],
+ [0x3d3, 0x3d4],
+ [0x400, 0x401],
+ [0x403],
+ [0x407],
+ [0x40c, 0x40e],
+ [0x419],
+ [0x439],
+ [0x450, 0x451],
+ [0x453],
+ [0x457],
+ [0x45c, 0x45e],
+ [0x476, 0x477],
+ [0x4c1, 0x4c2],
+ [0x4d0, 0x4d3],
+ [0x4d6, 0x4d7],
+ [0x4da, 0x4df],
+ [0x4e2, 0x4e7],
+ [0x4ea, 0x4f5],
+ [0x4f8, 0x4f9],
+ [0x622, 0x626],
+ [0x6c0],
+ [0x6c2],
+ [0x6d3],
+ [0x929],
+ [0x931],
+ [0x934],
+ [0x958, 0x95f],
+ [0x9dc, 0x9dd],
+ [0x9df],
+ [0xa33],
+ [0xa36],
+ [0xa59, 0xa5b],
+ [0xa5e],
+ [0xb5c, 0xb5d],
+ [0xb94],
+ [0xf43],
+ [0xf4d],
+ [0xf52],
+ [0xf57],
+ [0xf5c],
+ [0xf69],
+ [0x1026],
+ [0x1b06],
+ [0x1b08],
+ [0x1b0a],
+ [0x1b0c],
+ [0x1b0e],
+ [0x1b12],
+ [0x1e00, 0x1e99],
+ [0x1e9b],
+ [0x1ea0, 0x1ef9],
+ [0x1f00, 0x1f15],
+ [0x1f18, 0x1f1d],
+ [0x1f20, 0x1f45],
+ [0x1f48, 0x1f4d],
+ [0x1f50, 0x1f57],
+ [0x1f59],
+ [0x1f5b],
+ [0x1f5d],
+ [0x1f5f, 0x1f70],
+ [0x1f72],
+ [0x1f74],
+ [0x1f76],
+ [0x1f78],
+ [0x1f7a],
+ [0x1f7c],
+ [0x1f80, 0x1fb4],
+ [0x1fb6, 0x1fba],
+ [0x1fbc],
+ [0x1fc1, 0x1fc4],
+ [0x1fc6, 0x1fc8],
+ [0x1fca],
+ [0x1fcc, 0x1fd2],
+ [0x1fd6, 0x1fda],
+ [0x1fdd, 0x1fe2],
+ [0x1fe4, 0x1fea],
+ [0x1fec, 0x1fed],
+ [0x1ff2, 0x1ff4],
+ [0x1ff6, 0x1ff8],
+ [0x1ffa],
+ [0x1ffc],
+ [0x219a, 0x219b],
+ [0x21ae],
+ [0x21cd, 0x21cf],
+ [0x2204],
+ [0x2209],
+ [0x220c],
+ [0x2224],
+ [0x2226],
+ [0x2241],
+ [0x2244],
+ [0x2247],
+ [0x2249],
+ [0x2260],
+ [0x2262],
+ [0x226d, 0x2271],
+ [0x2274, 0x2275],
+ [0x2278, 0x2279],
+ [0x2280, 0x2281],
+ [0x2284, 0x2285],
+ [0x2288, 0x2289],
+ [0x22ac, 0x22af],
+ [0x22e0, 0x22e3],
+ [0x22ea, 0x22ed],
+ [0x2adc],
+ [0x304c],
+ [0x304e],
+ [0x3050],
+ [0x3052],
+ [0x3054],
+ [0x3056],
+ [0x3058],
+ [0x305a],
+ [0x305c],
+ [0x305e],
+ [0x3060],
+ [0x3062],
+ [0x3065],
+ [0x3067],
+ [0x3069],
+ [0x3070, 0x3071],
+ [0x3073, 0x3074],
+ [0x3076, 0x3077],
+ [0x3079, 0x307a],
+ [0x307c, 0x307d],
+ [0x3094],
+ [0x309e],
+ [0x30ac],
+ [0x30ae],
+ [0x30b0],
+ [0x30b2],
+ [0x30b4],
+ [0x30b6],
+ [0x30b8],
+ [0x30ba],
+ [0x30bc],
+ [0x30be],
+ [0x30c0],
+ [0x30c2],
+ [0x30c5],
+ [0x30c7],
+ [0x30c9],
+ [0x30d0, 0x30d1],
+ [0x30d3, 0x30d4],
+ [0x30d6, 0x30d7],
+ [0x30d9, 0x30da],
+ [0x30dc, 0x30dd],
+ [0x30f4],
+ [0x30f7, 0x30fa],
+ [0x30fe],
+ [0xac00],
+ [0xd7a3],
+ [0xfb1d],
+ [0xfb1f],
+ [0xfb2a, 0xfb36],
+ [0xfb38, 0xfb3c],
+ [0xfb3e],
+ [0xfb40, 0xfb41],
+ [0xfb43, 0xfb44],
+ [0xfb46, 0xfb4e],
+ [0x1109a],
+ [0x1109c],
+ [0x110ab],
+ [0x1d15e, 0x1d164],
+ [0x1d1bb, 0x1d1c0],
+];
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/ArrayInt64.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/ArrayInt64.js
new file mode 100644
index 0000000000000000000000000000000000000000..ec2cafaaf6a0708df63af5ec7bfb11b37352a105
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/ArrayInt64.js
@@ -0,0 +1,86 @@
+export const Zero64 = { sign: 1, data: [0, 0] };
+export const Unit64 = { sign: 1, data: [0, 1] };
+export function isZero64(a) {
+ return a.data[0] === 0 && a.data[1] === 0;
+}
+export function isStrictlyNegative64(a) {
+ return a.sign === -1 && !isZero64(a);
+}
+export function isStrictlyPositive64(a) {
+ return a.sign === 1 && !isZero64(a);
+}
+export function isEqual64(a, b) {
+ if (a.data[0] === b.data[0] && a.data[1] === b.data[1]) {
+ return a.sign === b.sign || (a.data[0] === 0 && a.data[1] === 0);
+ }
+ return false;
+}
+function isStrictlySmaller64Internal(a, b) {
+ return a[0] < b[0] || (a[0] === b[0] && a[1] < b[1]);
+}
+export function isStrictlySmaller64(a, b) {
+ if (a.sign === b.sign) {
+ return a.sign === 1
+ ? isStrictlySmaller64Internal(a.data, b.data)
+ : isStrictlySmaller64Internal(b.data, a.data);
+ }
+ return a.sign === -1 && (!isZero64(a) || !isZero64(b));
+}
+export function clone64(a) {
+ return { sign: a.sign, data: [a.data[0], a.data[1]] };
+}
+function substract64DataInternal(a, b) {
+ let reminderLow = 0;
+ let low = a[1] - b[1];
+ if (low < 0) {
+ reminderLow = 1;
+ low = low >>> 0;
+ }
+ return [a[0] - b[0] - reminderLow, low];
+}
+function substract64Internal(a, b) {
+ if (a.sign === 1 && b.sign === -1) {
+ const low = a.data[1] + b.data[1];
+ const high = a.data[0] + b.data[0] + (low > 0xffffffff ? 1 : 0);
+ return { sign: 1, data: [high >>> 0, low >>> 0] };
+ }
+ return {
+ sign: 1,
+ data: a.sign === 1 ? substract64DataInternal(a.data, b.data) : substract64DataInternal(b.data, a.data),
+ };
+}
+export function substract64(arrayIntA, arrayIntB) {
+ if (isStrictlySmaller64(arrayIntA, arrayIntB)) {
+ const out = substract64Internal(arrayIntB, arrayIntA);
+ out.sign = -1;
+ return out;
+ }
+ return substract64Internal(arrayIntA, arrayIntB);
+}
+export function negative64(arrayIntA) {
+ return {
+ sign: -arrayIntA.sign,
+ data: [arrayIntA.data[0], arrayIntA.data[1]],
+ };
+}
+export function add64(arrayIntA, arrayIntB) {
+ if (isZero64(arrayIntB)) {
+ if (isZero64(arrayIntA)) {
+ return clone64(Zero64);
+ }
+ return clone64(arrayIntA);
+ }
+ return substract64(arrayIntA, negative64(arrayIntB));
+}
+export function halve64(a) {
+ return {
+ sign: a.sign,
+ data: [Math.floor(a.data[0] / 2), (a.data[0] % 2 === 1 ? 0x80000000 : 0) + Math.floor(a.data[1] / 2)],
+ };
+}
+export function logLike64(a) {
+ return {
+ sign: a.sign,
+ data: [0, Math.floor(Math.log(a.data[0] * 0x100000000 + a.data[1]) / Math.log(2))],
+ };
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/BiasNumericRange.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/BiasNumericRange.js
new file mode 100644
index 0000000000000000000000000000000000000000..8e4fa9f422e257d42c42110292d7d1d537015f1b
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/BiasNumericRange.js
@@ -0,0 +1,32 @@
+import { BigInt, String } from '../../../utils/globals.js';
+const safeMathFloor = Math.floor;
+const safeMathLog = Math.log;
+export function integerLogLike(v) {
+ return safeMathFloor(safeMathLog(v) / safeMathLog(2));
+}
+export function bigIntLogLike(v) {
+ if (v === BigInt(0))
+ return BigInt(0);
+ return BigInt(String(v).length);
+}
+function biasNumericRange(min, max, logLike) {
+ if (min === max) {
+ return [{ min: min, max: max }];
+ }
+ if (min < 0 && max > 0) {
+ const logMin = logLike(-min);
+ const logMax = logLike(max);
+ return [
+ { min: -logMin, max: logMax },
+ { min: (max - logMax), max: max },
+ { min: min, max: min + logMin },
+ ];
+ }
+ const logGap = logLike((max - min));
+ const arbCloseToMin = { min: min, max: min + logGap };
+ const arbCloseToMax = { min: (max - logGap), max: max };
+ return min < 0
+ ? [arbCloseToMax, arbCloseToMin]
+ : [arbCloseToMin, arbCloseToMax];
+}
+export { biasNumericRange };
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/BuildSchedulerFor.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/BuildSchedulerFor.js
new file mode 100644
index 0000000000000000000000000000000000000000..c876d7ef0abdcaf9059ce043ab06791b156c5678
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/BuildSchedulerFor.js
@@ -0,0 +1,21 @@
+import { SchedulerImplem } from '../implementations/SchedulerImplem.js';
+function buildNextTaskIndex(ordering) {
+ let numTasks = 0;
+ return {
+ clone: () => buildNextTaskIndex(ordering),
+ nextTaskIndex: (scheduledTasks) => {
+ if (ordering.length <= numTasks) {
+ throw new Error(`Invalid schedulerFor defined: too many tasks have been scheduled`);
+ }
+ const taskIndex = scheduledTasks.findIndex((t) => t.taskId === ordering[numTasks]);
+ if (taskIndex === -1) {
+ throw new Error(`Invalid schedulerFor defined: unable to find next task`);
+ }
+ ++numTasks;
+ return taskIndex;
+ },
+ };
+}
+export function buildSchedulerFor(act, ordering) {
+ return new SchedulerImplem(act, buildNextTaskIndex(ordering));
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/BuildSlicedGenerator.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/BuildSlicedGenerator.js
new file mode 100644
index 0000000000000000000000000000000000000000..8ccc1f56a8ec135051456be09079a69804e42d14
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/BuildSlicedGenerator.js
@@ -0,0 +1,8 @@
+import { NoopSlicedGenerator } from '../implementations/NoopSlicedGenerator.js';
+import { SlicedBasedGenerator } from '../implementations/SlicedBasedGenerator.js';
+export function buildSlicedGenerator(arb, mrng, slices, biasFactor) {
+ if (biasFactor === undefined || slices.length === 0 || mrng.nextInt(1, biasFactor) !== 1) {
+ return new NoopSlicedGenerator(arb, mrng, biasFactor);
+ }
+ return new SlicedBasedGenerator(arb, mrng, slices, biasFactor);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/CustomEqualSet.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/CustomEqualSet.js
new file mode 100644
index 0000000000000000000000000000000000000000..68a87c9699ca6186b52fa56a5c2783ed47446b4b
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/CustomEqualSet.js
@@ -0,0 +1,22 @@
+import { safePush } from '../../../utils/globals.js';
+export class CustomEqualSet {
+ constructor(isEqual) {
+ this.isEqual = isEqual;
+ this.data = [];
+ }
+ tryAdd(value) {
+ for (let idx = 0; idx !== this.data.length; ++idx) {
+ if (this.isEqual(this.data[idx], value)) {
+ return false;
+ }
+ }
+ safePush(this.data, value);
+ return true;
+ }
+ size() {
+ return this.data.length;
+ }
+ getData() {
+ return this.data;
+ }
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/DepthContext.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/DepthContext.js
new file mode 100644
index 0000000000000000000000000000000000000000..e528a8c73a1510c256510857bf546c0b3e32419e
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/DepthContext.js
@@ -0,0 +1,21 @@
+import { safeMapGet, safeMapSet } from '../../../utils/globals.js';
+const depthContextCache = new Map();
+export function getDepthContextFor(contextMeta) {
+ if (contextMeta === undefined) {
+ return { depth: 0 };
+ }
+ if (typeof contextMeta !== 'string') {
+ return contextMeta;
+ }
+ const cachedContext = safeMapGet(depthContextCache, contextMeta);
+ if (cachedContext !== undefined) {
+ return cachedContext;
+ }
+ const context = { depth: 0 };
+ safeMapSet(depthContextCache, contextMeta, context);
+ return context;
+}
+export function createDepthIdentifier() {
+ const identifier = { depth: 0 };
+ return identifier;
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/DoubleHelpers.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/DoubleHelpers.js
new file mode 100644
index 0000000000000000000000000000000000000000..8892496e023b1bc47c4e1bed6093babcdc9f8e46
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/DoubleHelpers.js
@@ -0,0 +1,85 @@
+import { clone64, isEqual64 } from './ArrayInt64.js';
+const safeNegativeInfinity = Number.NEGATIVE_INFINITY;
+const safePositiveInfinity = Number.POSITIVE_INFINITY;
+const safeEpsilon = Number.EPSILON;
+const INDEX_POSITIVE_INFINITY = { sign: 1, data: [2146435072, 0] };
+const INDEX_NEGATIVE_INFINITY = { sign: -1, data: [2146435072, 1] };
+const f64 = new Float64Array(1);
+const u32 = new Uint32Array(f64.buffer, f64.byteOffset);
+function bitCastDoubleToUInt64(f) {
+ f64[0] = f;
+ return [u32[1], u32[0]];
+}
+export function decomposeDouble(d) {
+ const { 0: hi, 1: lo } = bitCastDoubleToUInt64(d);
+ const signBit = hi >>> 31;
+ const exponentBits = (hi >>> 20) & 0x7ff;
+ const significandBits = (hi & 0xfffff) * 0x100000000 + lo;
+ const exponent = exponentBits === 0 ? -1022 : exponentBits - 1023;
+ let significand = exponentBits === 0 ? 0 : 1;
+ significand += significandBits / 2 ** 52;
+ significand *= signBit === 0 ? 1 : -1;
+ return { exponent, significand };
+}
+function positiveNumberToInt64(n) {
+ return [~~(n / 0x100000000), n >>> 0];
+}
+function indexInDoubleFromDecomp(exponent, significand) {
+ if (exponent === -1022) {
+ const rescaledSignificand = significand * 2 ** 52;
+ return positiveNumberToInt64(rescaledSignificand);
+ }
+ const rescaledSignificand = (significand - 1) * 2 ** 52;
+ const exponentOnlyHigh = (exponent + 1023) * 2 ** 20;
+ const index = positiveNumberToInt64(rescaledSignificand);
+ index[0] += exponentOnlyHigh;
+ return index;
+}
+export function doubleToIndex(d) {
+ if (d === safePositiveInfinity) {
+ return clone64(INDEX_POSITIVE_INFINITY);
+ }
+ if (d === safeNegativeInfinity) {
+ return clone64(INDEX_NEGATIVE_INFINITY);
+ }
+ const decomp = decomposeDouble(d);
+ const exponent = decomp.exponent;
+ const significand = decomp.significand;
+ if (d > 0 || (d === 0 && 1 / d === safePositiveInfinity)) {
+ return { sign: 1, data: indexInDoubleFromDecomp(exponent, significand) };
+ }
+ else {
+ const indexOpposite = indexInDoubleFromDecomp(exponent, -significand);
+ if (indexOpposite[1] === 0xffffffff) {
+ indexOpposite[0] += 1;
+ indexOpposite[1] = 0;
+ }
+ else {
+ indexOpposite[1] += 1;
+ }
+ return { sign: -1, data: indexOpposite };
+ }
+}
+export function indexToDouble(index) {
+ if (index.sign === -1) {
+ const indexOpposite = { sign: 1, data: [index.data[0], index.data[1]] };
+ if (indexOpposite.data[1] === 0) {
+ indexOpposite.data[0] -= 1;
+ indexOpposite.data[1] = 0xffffffff;
+ }
+ else {
+ indexOpposite.data[1] -= 1;
+ }
+ return -indexToDouble(indexOpposite);
+ }
+ if (isEqual64(index, INDEX_POSITIVE_INFINITY)) {
+ return safePositiveInfinity;
+ }
+ if (index.data[0] < 0x200000) {
+ return (index.data[0] * 0x100000000 + index.data[1]) * 2 ** -1074;
+ }
+ const postIndexHigh = index.data[0] - 0x200000;
+ const exponent = -1021 + (postIndexHigh >> 20);
+ const significand = 1 + ((postIndexHigh & 0xfffff) * 2 ** 32 + index.data[1]) * safeEpsilon;
+ return significand * 2 ** exponent;
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/DoubleOnlyHelpers.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/DoubleOnlyHelpers.js
new file mode 100644
index 0000000000000000000000000000000000000000..6e7cf3eee1ac324131ef6a7a444d9827ae8b72fd
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/DoubleOnlyHelpers.js
@@ -0,0 +1,25 @@
+import { refineConstraintsForFloatingOnly } from './FloatingOnlyHelpers.js';
+const safeNegativeInfinity = Number.NEGATIVE_INFINITY;
+const safePositiveInfinity = Number.POSITIVE_INFINITY;
+const safeMaxValue = Number.MAX_VALUE;
+export const maxNonIntegerValue = 4503599627370495.5;
+export const onlyIntegersAfterThisValue = 4503599627370496;
+export function refineConstraintsForDoubleOnly(constraints) {
+ return refineConstraintsForFloatingOnly(constraints, safeMaxValue, maxNonIntegerValue, onlyIntegersAfterThisValue);
+}
+export function doubleOnlyMapper(value) {
+ return value === onlyIntegersAfterThisValue
+ ? safePositiveInfinity
+ : value === -onlyIntegersAfterThisValue
+ ? safeNegativeInfinity
+ : value;
+}
+export function doubleOnlyUnmapper(value) {
+ if (typeof value !== 'number')
+ throw new Error('Unsupported type');
+ return value === safePositiveInfinity
+ ? onlyIntegersAfterThisValue
+ : value === safeNegativeInfinity
+ ? -onlyIntegersAfterThisValue
+ : value;
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/EnumerableKeysExtractor.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/EnumerableKeysExtractor.js
new file mode 100644
index 0000000000000000000000000000000000000000..cba074a08cb67360793d21123c07398dc83ff3b5
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/EnumerableKeysExtractor.js
@@ -0,0 +1,15 @@
+const safeObjectKeys = Object.keys;
+const safeObjectGetOwnPropertySymbols = Object.getOwnPropertySymbols;
+const safeObjectGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+export function extractEnumerableKeys(instance) {
+ const keys = safeObjectKeys(instance);
+ const symbols = safeObjectGetOwnPropertySymbols(instance);
+ for (let index = 0; index !== symbols.length; ++index) {
+ const symbol = symbols[index];
+ const descriptor = safeObjectGetOwnPropertyDescriptor(instance, symbol);
+ if (descriptor && descriptor.enumerable) {
+ keys.push(symbol);
+ }
+ }
+ return keys;
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/FloatHelpers.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/FloatHelpers.js
new file mode 100644
index 0000000000000000000000000000000000000000..1263b82b7fa3c72e1e003ae6490edbf1fdcf3c66
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/FloatHelpers.js
@@ -0,0 +1,62 @@
+const safeNegativeInfinity = Number.NEGATIVE_INFINITY;
+const safePositiveInfinity = Number.POSITIVE_INFINITY;
+export const MIN_VALUE_32 = 2 ** -126 * 2 ** -23;
+export const MAX_VALUE_32 = 2 ** 127 * (1 + (2 ** 23 - 1) / 2 ** 23);
+export const EPSILON_32 = 2 ** -23;
+const INDEX_POSITIVE_INFINITY = 2139095040;
+const INDEX_NEGATIVE_INFINITY = -2139095041;
+const f32 = new Float32Array(1);
+const u32 = new Uint32Array(f32.buffer, f32.byteOffset);
+function bitCastFloatToUInt32(f) {
+ f32[0] = f;
+ return u32[0];
+}
+export function decomposeFloat(f) {
+ const bits = bitCastFloatToUInt32(f);
+ const signBit = bits >>> 31;
+ const exponentBits = (bits >>> 23) & 0xff;
+ const significandBits = bits & 0x7fffff;
+ const exponent = exponentBits === 0 ? -126 : exponentBits - 127;
+ let significand = exponentBits === 0 ? 0 : 1;
+ significand += significandBits / 2 ** 23;
+ significand *= signBit === 0 ? 1 : -1;
+ return { exponent, significand };
+}
+function indexInFloatFromDecomp(exponent, significand) {
+ if (exponent === -126) {
+ return significand * 0x800000;
+ }
+ return (exponent + 127) * 0x800000 + (significand - 1) * 0x800000;
+}
+export function floatToIndex(f) {
+ if (f === safePositiveInfinity) {
+ return INDEX_POSITIVE_INFINITY;
+ }
+ if (f === safeNegativeInfinity) {
+ return INDEX_NEGATIVE_INFINITY;
+ }
+ const decomp = decomposeFloat(f);
+ const exponent = decomp.exponent;
+ const significand = decomp.significand;
+ if (f > 0 || (f === 0 && 1 / f === safePositiveInfinity)) {
+ return indexInFloatFromDecomp(exponent, significand);
+ }
+ else {
+ return -indexInFloatFromDecomp(exponent, -significand) - 1;
+ }
+}
+export function indexToFloat(index) {
+ if (index < 0) {
+ return -indexToFloat(-index - 1);
+ }
+ if (index === INDEX_POSITIVE_INFINITY) {
+ return safePositiveInfinity;
+ }
+ if (index < 0x1000000) {
+ return index * 2 ** -149;
+ }
+ const postIndex = index - 0x1000000;
+ const exponent = -125 + (postIndex >> 23);
+ const significand = 1 + (postIndex & 0x7fffff) / 0x800000;
+ return significand * 2 ** exponent;
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/FloatOnlyHelpers.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/FloatOnlyHelpers.js
new file mode 100644
index 0000000000000000000000000000000000000000..a4126bffb0a5fdd38e5c41bb516456df0e20bcb1
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/FloatOnlyHelpers.js
@@ -0,0 +1,26 @@
+import { MAX_VALUE_32 } from './FloatHelpers.js';
+import { refineConstraintsForFloatingOnly } from './FloatingOnlyHelpers.js';
+const safeNegativeInfinity = Number.NEGATIVE_INFINITY;
+const safePositiveInfinity = Number.POSITIVE_INFINITY;
+const safeMaxValue = MAX_VALUE_32;
+export const maxNonIntegerValue = 8388607.5;
+export const onlyIntegersAfterThisValue = 8388608;
+export function refineConstraintsForFloatOnly(constraints) {
+ return refineConstraintsForFloatingOnly(constraints, safeMaxValue, maxNonIntegerValue, onlyIntegersAfterThisValue);
+}
+export function floatOnlyMapper(value) {
+ return value === onlyIntegersAfterThisValue
+ ? safePositiveInfinity
+ : value === -onlyIntegersAfterThisValue
+ ? safeNegativeInfinity
+ : value;
+}
+export function floatOnlyUnmapper(value) {
+ if (typeof value !== 'number')
+ throw new Error('Unsupported type');
+ return value === safePositiveInfinity
+ ? onlyIntegersAfterThisValue
+ : value === safeNegativeInfinity
+ ? -onlyIntegersAfterThisValue
+ : value;
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/FloatingOnlyHelpers.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/FloatingOnlyHelpers.js
new file mode 100644
index 0000000000000000000000000000000000000000..fc1232ca8095f0f1ecc6605f33917cd944d1d04e
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/FloatingOnlyHelpers.js
@@ -0,0 +1,30 @@
+const safeNumberIsInteger = Number.isInteger;
+const safeObjectIs = Object.is;
+const safeNegativeInfinity = Number.NEGATIVE_INFINITY;
+const safePositiveInfinity = Number.POSITIVE_INFINITY;
+export function refineConstraintsForFloatingOnly(constraints, maxValue, maxNonIntegerValue, onlyIntegersAfterThisValue) {
+ const { noDefaultInfinity = false, minExcluded = false, maxExcluded = false, min = noDefaultInfinity ? -maxValue : safeNegativeInfinity, max = noDefaultInfinity ? maxValue : safePositiveInfinity, } = constraints;
+ const effectiveMin = minExcluded
+ ? min < -maxNonIntegerValue
+ ? -onlyIntegersAfterThisValue
+ : Math.max(min, -maxNonIntegerValue)
+ : min === safeNegativeInfinity
+ ? Math.max(min, -onlyIntegersAfterThisValue)
+ : Math.max(min, -maxNonIntegerValue);
+ const effectiveMax = maxExcluded
+ ? max > maxNonIntegerValue
+ ? onlyIntegersAfterThisValue
+ : Math.min(max, maxNonIntegerValue)
+ : max === safePositiveInfinity
+ ? Math.min(max, onlyIntegersAfterThisValue)
+ : Math.min(max, maxNonIntegerValue);
+ const fullConstraints = {
+ noDefaultInfinity: false,
+ minExcluded: minExcluded || ((min !== safeNegativeInfinity || minExcluded) && safeNumberIsInteger(effectiveMin)),
+ maxExcluded: maxExcluded || ((max !== safePositiveInfinity || maxExcluded) && safeNumberIsInteger(effectiveMax)),
+ min: safeObjectIs(effectiveMin, -0) ? 0 : effectiveMin,
+ max: safeObjectIs(effectiveMax, 0) ? -0 : effectiveMax,
+ noNaN: constraints.noNaN || false,
+ };
+ return fullConstraints;
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/GraphemeRangesHelpers.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/GraphemeRangesHelpers.js
new file mode 100644
index 0000000000000000000000000000000000000000..b3bda3322be6cc1b231fbd0468b557cddf225e03
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/GraphemeRangesHelpers.js
@@ -0,0 +1,51 @@
+import { safePop, safePush } from '../../../utils/globals.js';
+const safeStringFromCodePoint = String.fromCodePoint;
+const safeMathMin = Math.min;
+const safeMathMax = Math.max;
+export function convertGraphemeRangeToMapToConstantEntry(range) {
+ if (range.length === 1) {
+ const codePointString = safeStringFromCodePoint(range[0]);
+ return { num: 1, build: () => codePointString };
+ }
+ const rangeStart = range[0];
+ return { num: range[1] - range[0] + 1, build: (idInGroup) => safeStringFromCodePoint(rangeStart + idInGroup) };
+}
+export function intersectGraphemeRanges(rangesA, rangesB) {
+ const mergedRanges = [];
+ let cursorA = 0;
+ let cursorB = 0;
+ while (cursorA < rangesA.length && cursorB < rangesB.length) {
+ const rangeA = rangesA[cursorA];
+ const rangeAMin = rangeA[0];
+ const rangeAMax = rangeA.length === 1 ? rangeA[0] : rangeA[1];
+ const rangeB = rangesB[cursorB];
+ const rangeBMin = rangeB[0];
+ const rangeBMax = rangeB.length === 1 ? rangeB[0] : rangeB[1];
+ if (rangeAMax < rangeBMin) {
+ cursorA += 1;
+ }
+ else if (rangeBMax < rangeAMin) {
+ cursorB += 1;
+ }
+ else {
+ let min = safeMathMax(rangeAMin, rangeBMin);
+ const max = safeMathMin(rangeAMax, rangeBMax);
+ if (mergedRanges.length >= 1) {
+ const lastMergedRange = mergedRanges[mergedRanges.length - 1];
+ const lastMergedRangeMax = lastMergedRange.length === 1 ? lastMergedRange[0] : lastMergedRange[1];
+ if (lastMergedRangeMax + 1 === min) {
+ min = lastMergedRange[0];
+ safePop(mergedRanges);
+ }
+ }
+ safePush(mergedRanges, min === max ? [min] : [min, max]);
+ if (rangeAMax <= max) {
+ cursorA += 1;
+ }
+ if (rangeBMax <= max) {
+ cursorB += 1;
+ }
+ }
+ }
+ return mergedRanges;
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/InvalidSubdomainLabelFiIter.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/InvalidSubdomainLabelFiIter.js
new file mode 100644
index 0000000000000000000000000000000000000000..dc7c0faefa642e558a36875c71420a41cccabc46
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/InvalidSubdomainLabelFiIter.js
@@ -0,0 +1,10 @@
+export function filterInvalidSubdomainLabel(subdomainLabel) {
+ if (subdomainLabel.length > 63) {
+ return false;
+ }
+ return (subdomainLabel.length < 4 ||
+ subdomainLabel[0] !== 'x' ||
+ subdomainLabel[1] !== 'n' ||
+ subdomainLabel[2] !== '-' ||
+ subdomainLabel[3] !== '-');
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/IsSubarrayOf.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/IsSubarrayOf.js
new file mode 100644
index 0000000000000000000000000000000000000000..4b74bd8f39a009fe331ad19483e22608fa4ee478
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/IsSubarrayOf.js
@@ -0,0 +1,33 @@
+import { Map, safeMapGet, safeMapSet } from '../../../utils/globals.js';
+const safeObjectIs = Object.is;
+export function isSubarrayOf(source, small) {
+ const countMap = new Map();
+ let countMinusZero = 0;
+ for (const sourceEntry of source) {
+ if (safeObjectIs(sourceEntry, -0)) {
+ ++countMinusZero;
+ }
+ else {
+ const oldCount = safeMapGet(countMap, sourceEntry) || 0;
+ safeMapSet(countMap, sourceEntry, oldCount + 1);
+ }
+ }
+ for (let index = 0; index !== small.length; ++index) {
+ if (!(index in small)) {
+ return false;
+ }
+ const smallEntry = small[index];
+ if (safeObjectIs(smallEntry, -0)) {
+ if (countMinusZero === 0)
+ return false;
+ --countMinusZero;
+ }
+ else {
+ const oldCount = safeMapGet(countMap, smallEntry) || 0;
+ if (oldCount === 0)
+ return false;
+ safeMapSet(countMap, smallEntry, oldCount - 1);
+ }
+ }
+ return true;
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/JsonConstraintsBuilder.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/JsonConstraintsBuilder.js
new file mode 100644
index 0000000000000000000000000000000000000000..f332fcd4ff48eee01a0225c6012188fed8376489
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/JsonConstraintsBuilder.js
@@ -0,0 +1,14 @@
+import { boolean } from '../../boolean.js';
+import { constant } from '../../constant.js';
+import { double } from '../../double.js';
+export function jsonConstraintsBuilder(stringArbitrary, constraints) {
+ const { depthSize, maxDepth } = constraints;
+ const key = stringArbitrary;
+ const values = [
+ boolean(),
+ double({ noDefaultInfinity: true, noNaN: true }),
+ stringArbitrary,
+ constant(null),
+ ];
+ return { key, values, depthSize, maxDepth };
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/MaxLengthFromMinLength.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/MaxLengthFromMinLength.js
new file mode 100644
index 0000000000000000000000000000000000000000..58ee6f634463d1cb9fa4b1ed22de1f6d92fa144b
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/MaxLengthFromMinLength.js
@@ -0,0 +1,83 @@
+import { readConfigureGlobal } from '../../../check/runner/configuration/GlobalParameters.js';
+import { safeIndexOf } from '../../../utils/globals.js';
+const safeMathFloor = Math.floor;
+const safeMathMin = Math.min;
+export const MaxLengthUpperBound = 0x7fffffff;
+const orderedSize = ['xsmall', 'small', 'medium', 'large', 'xlarge'];
+const orderedRelativeSize = ['-4', '-3', '-2', '-1', '=', '+1', '+2', '+3', '+4'];
+export const DefaultSize = 'small';
+export function maxLengthFromMinLength(minLength, size) {
+ switch (size) {
+ case 'xsmall':
+ return safeMathFloor(1.1 * minLength) + 1;
+ case 'small':
+ return 2 * minLength + 10;
+ case 'medium':
+ return 11 * minLength + 100;
+ case 'large':
+ return 101 * minLength + 1000;
+ case 'xlarge':
+ return 1001 * minLength + 10000;
+ default:
+ throw new Error(`Unable to compute lengths based on received size: ${size}`);
+ }
+}
+export function relativeSizeToSize(size, defaultSize) {
+ const sizeInRelative = safeIndexOf(orderedRelativeSize, size);
+ if (sizeInRelative === -1) {
+ return size;
+ }
+ const defaultSizeInSize = safeIndexOf(orderedSize, defaultSize);
+ if (defaultSizeInSize === -1) {
+ throw new Error(`Unable to offset size based on the unknown defaulted one: ${defaultSize}`);
+ }
+ const resultingSizeInSize = defaultSizeInSize + sizeInRelative - 4;
+ return resultingSizeInSize < 0
+ ? orderedSize[0]
+ : resultingSizeInSize >= orderedSize.length
+ ? orderedSize[orderedSize.length - 1]
+ : orderedSize[resultingSizeInSize];
+}
+export function maxGeneratedLengthFromSizeForArbitrary(size, minLength, maxLength, specifiedMaxLength) {
+ const { baseSize: defaultSize = DefaultSize, defaultSizeToMaxWhenMaxSpecified } = readConfigureGlobal() || {};
+ const definedSize = size !== undefined ? size : specifiedMaxLength && defaultSizeToMaxWhenMaxSpecified ? 'max' : defaultSize;
+ if (definedSize === 'max') {
+ return maxLength;
+ }
+ const finalSize = relativeSizeToSize(definedSize, defaultSize);
+ return safeMathMin(maxLengthFromMinLength(minLength, finalSize), maxLength);
+}
+export function depthBiasFromSizeForArbitrary(depthSizeOrSize, specifiedMaxDepth) {
+ if (typeof depthSizeOrSize === 'number') {
+ return 1 / depthSizeOrSize;
+ }
+ const { baseSize: defaultSize = DefaultSize, defaultSizeToMaxWhenMaxSpecified } = readConfigureGlobal() || {};
+ const definedSize = depthSizeOrSize !== undefined
+ ? depthSizeOrSize
+ : specifiedMaxDepth && defaultSizeToMaxWhenMaxSpecified
+ ? 'max'
+ : defaultSize;
+ if (definedSize === 'max') {
+ return 0;
+ }
+ const finalSize = relativeSizeToSize(definedSize, defaultSize);
+ switch (finalSize) {
+ case 'xsmall':
+ return 1;
+ case 'small':
+ return 0.5;
+ case 'medium':
+ return 0.25;
+ case 'large':
+ return 0.125;
+ case 'xlarge':
+ return 0.0625;
+ }
+}
+export function resolveSize(size) {
+ const { baseSize: defaultSize = DefaultSize } = readConfigureGlobal() || {};
+ if (size === undefined) {
+ return defaultSize;
+ }
+ return relativeSizeToSize(size, defaultSize);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/NoUndefinedAsContext.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/NoUndefinedAsContext.js
new file mode 100644
index 0000000000000000000000000000000000000000..5450090abf484e1db1f6e25e04405493e304cd03
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/NoUndefinedAsContext.js
@@ -0,0 +1,11 @@
+import { Value } from '../../../check/arbitrary/definition/Value.js';
+export const UndefinedContextPlaceholder = Symbol('UndefinedContextPlaceholder');
+export function noUndefinedAsContext(value) {
+ if (value.context !== undefined) {
+ return value;
+ }
+ if (value.hasToBeCloned) {
+ return new Value(value.value_, UndefinedContextPlaceholder, () => value.value);
+ }
+ return new Value(value.value_, UndefinedContextPlaceholder);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/QualifiedObjectConstraints.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/QualifiedObjectConstraints.js
new file mode 100644
index 0000000000000000000000000000000000000000..c252d93cf485449d3f080d055cc98689bb442d5f
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/QualifiedObjectConstraints.js
@@ -0,0 +1,46 @@
+import { boolean } from '../../boolean.js';
+import { constant } from '../../constant.js';
+import { double } from '../../double.js';
+import { fullUnicodeString } from '../../fullUnicodeString.js';
+import { maxSafeInteger } from '../../maxSafeInteger.js';
+import { oneof } from '../../oneof.js';
+import { string } from '../../string.js';
+import { boxedArbitraryBuilder } from '../builders/BoxedArbitraryBuilder.js';
+function defaultValues(constraints, stringArbitrary) {
+ return [
+ boolean(),
+ maxSafeInteger(),
+ double(),
+ stringArbitrary(constraints),
+ oneof(stringArbitrary(constraints), constant(null), constant(undefined)),
+ ];
+}
+function boxArbitraries(arbs) {
+ return arbs.map((arb) => boxedArbitraryBuilder(arb));
+}
+function boxArbitrariesIfNeeded(arbs, boxEnabled) {
+ return boxEnabled ? boxArbitraries(arbs).concat(arbs) : arbs;
+}
+export function toQualifiedObjectConstraints(settings = {}) {
+ function orDefault(optionalValue, defaultValue) {
+ return optionalValue !== undefined ? optionalValue : defaultValue;
+ }
+ const stringArbitrary = 'stringUnit' in settings ? string : settings.withUnicodeString ? fullUnicodeString : string;
+ const valueConstraints = { size: settings.size, unit: settings.stringUnit };
+ return {
+ key: orDefault(settings.key, stringArbitrary(valueConstraints)),
+ values: boxArbitrariesIfNeeded(orDefault(settings.values, defaultValues(valueConstraints, stringArbitrary)), orDefault(settings.withBoxedValues, false)),
+ depthSize: settings.depthSize,
+ maxDepth: settings.maxDepth,
+ maxKeys: settings.maxKeys,
+ size: settings.size,
+ withSet: orDefault(settings.withSet, false),
+ withMap: orDefault(settings.withMap, false),
+ withObjectString: orDefault(settings.withObjectString, false),
+ withNullPrototype: orDefault(settings.withNullPrototype, false),
+ withBigInt: orDefault(settings.withBigInt, false),
+ withDate: orDefault(settings.withDate, false),
+ withTypedArray: orDefault(settings.withTypedArray, false),
+ withSparseArray: orDefault(settings.withSparseArray, false),
+ };
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/ReadRegex.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/ReadRegex.js
new file mode 100644
index 0000000000000000000000000000000000000000..1162788c95e4990b86c5e79f5bc48788934a18a6
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/ReadRegex.js
@@ -0,0 +1,207 @@
+function charSizeAt(text, pos) {
+ return text[pos] >= '\uD800' && text[pos] <= '\uDBFF' && text[pos + 1] >= '\uDC00' && text[pos + 1] <= '\uDFFF'
+ ? 2
+ : 1;
+}
+function isHexaDigit(char) {
+ return (char >= '0' && char <= '9') || (char >= 'a' && char <= 'f') || (char >= 'A' && char <= 'F');
+}
+function isDigit(char) {
+ return char >= '0' && char <= '9';
+}
+function squaredBracketBlockContentEndFrom(text, from) {
+ for (let index = from; index !== text.length; ++index) {
+ const char = text[index];
+ if (char === '\\') {
+ index += 1;
+ }
+ else if (char === ']') {
+ return index;
+ }
+ }
+ throw new Error(`Missing closing ']'`);
+}
+function parenthesisBlockContentEndFrom(text, from) {
+ let numExtraOpened = 0;
+ for (let index = from; index !== text.length; ++index) {
+ const char = text[index];
+ if (char === '\\') {
+ index += 1;
+ }
+ else if (char === ')') {
+ if (numExtraOpened === 0) {
+ return index;
+ }
+ numExtraOpened -= 1;
+ }
+ else if (char === '[') {
+ index = squaredBracketBlockContentEndFrom(text, index);
+ }
+ else if (char === '(') {
+ numExtraOpened += 1;
+ }
+ }
+ throw new Error(`Missing closing ')'`);
+}
+function curlyBracketBlockContentEndFrom(text, from) {
+ let foundComma = false;
+ for (let index = from; index !== text.length; ++index) {
+ const char = text[index];
+ if (isDigit(char)) {
+ }
+ else if (from === index) {
+ return -1;
+ }
+ else if (char === ',') {
+ if (foundComma) {
+ return -1;
+ }
+ foundComma = true;
+ }
+ else if (char === '}') {
+ return index;
+ }
+ else {
+ return -1;
+ }
+ }
+ return -1;
+}
+export var TokenizerBlockMode;
+(function (TokenizerBlockMode) {
+ TokenizerBlockMode[TokenizerBlockMode["Full"] = 0] = "Full";
+ TokenizerBlockMode[TokenizerBlockMode["Character"] = 1] = "Character";
+})(TokenizerBlockMode || (TokenizerBlockMode = {}));
+function blockEndFrom(text, from, unicodeMode, mode) {
+ switch (text[from]) {
+ case '[': {
+ if (mode === TokenizerBlockMode.Character) {
+ return from + 1;
+ }
+ return squaredBracketBlockContentEndFrom(text, from + 1) + 1;
+ }
+ case '{': {
+ if (mode === TokenizerBlockMode.Character) {
+ return from + 1;
+ }
+ const foundEnd = curlyBracketBlockContentEndFrom(text, from + 1);
+ if (foundEnd === -1) {
+ return from + 1;
+ }
+ return foundEnd + 1;
+ }
+ case '(': {
+ if (mode === TokenizerBlockMode.Character) {
+ return from + 1;
+ }
+ return parenthesisBlockContentEndFrom(text, from + 1) + 1;
+ }
+ case ']':
+ case '}':
+ case ')':
+ return from + 1;
+ case '\\': {
+ const next1 = text[from + 1];
+ switch (next1) {
+ case 'x':
+ if (isHexaDigit(text[from + 2]) && isHexaDigit(text[from + 3])) {
+ return from + 4;
+ }
+ throw new Error(`Unexpected token '${text.substring(from, from + 4)}' found`);
+ case 'u':
+ if (text[from + 2] === '{') {
+ if (!unicodeMode) {
+ return from + 2;
+ }
+ if (text[from + 4] === '}') {
+ if (isHexaDigit(text[from + 3])) {
+ return from + 5;
+ }
+ throw new Error(`Unexpected token '${text.substring(from, from + 5)}' found`);
+ }
+ if (text[from + 5] === '}') {
+ if (isHexaDigit(text[from + 3]) && isHexaDigit(text[from + 4])) {
+ return from + 6;
+ }
+ throw new Error(`Unexpected token '${text.substring(from, from + 6)}' found`);
+ }
+ if (text[from + 6] === '}') {
+ if (isHexaDigit(text[from + 3]) && isHexaDigit(text[from + 4]) && isHexaDigit(text[from + 5])) {
+ return from + 7;
+ }
+ throw new Error(`Unexpected token '${text.substring(from, from + 7)}' found`);
+ }
+ if (text[from + 7] === '}') {
+ if (isHexaDigit(text[from + 3]) &&
+ isHexaDigit(text[from + 4]) &&
+ isHexaDigit(text[from + 5]) &&
+ isHexaDigit(text[from + 6])) {
+ return from + 8;
+ }
+ throw new Error(`Unexpected token '${text.substring(from, from + 8)}' found`);
+ }
+ if (text[from + 8] === '}' &&
+ isHexaDigit(text[from + 3]) &&
+ isHexaDigit(text[from + 4]) &&
+ isHexaDigit(text[from + 5]) &&
+ isHexaDigit(text[from + 6]) &&
+ isHexaDigit(text[from + 7])) {
+ return from + 9;
+ }
+ throw new Error(`Unexpected token '${text.substring(from, from + 9)}' found`);
+ }
+ if (isHexaDigit(text[from + 2]) &&
+ isHexaDigit(text[from + 3]) &&
+ isHexaDigit(text[from + 4]) &&
+ isHexaDigit(text[from + 5])) {
+ return from + 6;
+ }
+ throw new Error(`Unexpected token '${text.substring(from, from + 6)}' found`);
+ case 'p':
+ case 'P': {
+ if (!unicodeMode) {
+ return from + 2;
+ }
+ let subIndex = from + 2;
+ for (; subIndex < text.length && text[subIndex] !== '}'; subIndex += text[subIndex] === '\\' ? 2 : 1) {
+ }
+ if (text[subIndex] !== '}') {
+ throw new Error(`Invalid \\P definition`);
+ }
+ return subIndex + 1;
+ }
+ case 'k': {
+ let subIndex = from + 2;
+ for (; subIndex < text.length && text[subIndex] !== '>'; ++subIndex) {
+ }
+ if (text[subIndex] !== '>') {
+ if (!unicodeMode) {
+ return from + 2;
+ }
+ throw new Error(`Invalid \\k definition`);
+ }
+ return subIndex + 1;
+ }
+ default: {
+ if (isDigit(next1)) {
+ const maxIndex = unicodeMode ? text.length : Math.min(from + 4, text.length);
+ let subIndex = from + 2;
+ for (; subIndex < maxIndex && isDigit(text[subIndex]); ++subIndex) {
+ }
+ return subIndex;
+ }
+ const charSize = unicodeMode ? charSizeAt(text, from + 1) : 1;
+ return from + charSize + 1;
+ }
+ }
+ }
+ default: {
+ const charSize = unicodeMode ? charSizeAt(text, from) : 1;
+ return from + charSize;
+ }
+ }
+}
+export function readFrom(text, from, unicodeMode, mode) {
+ const to = blockEndFrom(text, from, unicodeMode, mode);
+ return text.substring(from, to);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/SameValueSet.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/SameValueSet.js
new file mode 100644
index 0000000000000000000000000000000000000000..444903a51e07214bac68c49d5585d53e5741fd32
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/SameValueSet.js
@@ -0,0 +1,34 @@
+import { Set, safeAdd, safePush } from '../../../utils/globals.js';
+const safeObjectIs = Object.is;
+export class SameValueSet {
+ constructor(selector) {
+ this.selector = selector;
+ this.selectedItemsExceptMinusZero = new Set();
+ this.data = [];
+ this.hasMinusZero = false;
+ }
+ tryAdd(value) {
+ const selected = this.selector(value);
+ if (safeObjectIs(selected, -0)) {
+ if (this.hasMinusZero) {
+ return false;
+ }
+ safePush(this.data, value);
+ this.hasMinusZero = true;
+ return true;
+ }
+ const sizeBefore = this.selectedItemsExceptMinusZero.size;
+ safeAdd(this.selectedItemsExceptMinusZero, selected);
+ if (sizeBefore !== this.selectedItemsExceptMinusZero.size) {
+ safePush(this.data, value);
+ return true;
+ }
+ return false;
+ }
+ size() {
+ return this.data.length;
+ }
+ getData() {
+ return this.data;
+ }
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/SameValueZeroSet.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/SameValueZeroSet.js
new file mode 100644
index 0000000000000000000000000000000000000000..8969b1f451854f0ead4ddf2469f628ca94fa1faa
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/SameValueZeroSet.js
@@ -0,0 +1,24 @@
+import { Set, safeAdd, safePush } from '../../../utils/globals.js';
+export class SameValueZeroSet {
+ constructor(selector) {
+ this.selector = selector;
+ this.selectedItems = new Set();
+ this.data = [];
+ }
+ tryAdd(value) {
+ const selected = this.selector(value);
+ const sizeBefore = this.selectedItems.size;
+ safeAdd(this.selectedItems, selected);
+ if (sizeBefore !== this.selectedItems.size) {
+ safePush(this.data, value);
+ return true;
+ }
+ return false;
+ }
+ size() {
+ return this.data.length;
+ }
+ getData() {
+ return this.data;
+ }
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/SanitizeRegexAst.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/SanitizeRegexAst.js
new file mode 100644
index 0000000000000000000000000000000000000000..9ce926895eb91449a7a444d5e7a98262dedaf61d
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/SanitizeRegexAst.js
@@ -0,0 +1,81 @@
+import { stringify } from '../../../utils/stringify.js';
+function raiseUnsupportedASTNode(astNode) {
+ return new Error(`Unsupported AST node! Received: ${stringify(astNode)}`);
+}
+function addMissingDotStarTraversalAddMissing(astNode, isFirst, isLast) {
+ if (!isFirst && !isLast) {
+ return astNode;
+ }
+ const traversalResults = { hasStart: false, hasEnd: false };
+ const revampedNode = addMissingDotStarTraversal(astNode, isFirst, isLast, traversalResults);
+ const missingStart = isFirst && !traversalResults.hasStart;
+ const missingEnd = isLast && !traversalResults.hasEnd;
+ if (!missingStart && !missingEnd) {
+ return revampedNode;
+ }
+ const expressions = [];
+ if (missingStart) {
+ expressions.push({ type: 'Assertion', kind: '^' });
+ expressions.push({
+ type: 'Repetition',
+ quantifier: { type: 'Quantifier', kind: '*', greedy: true },
+ expression: { type: 'Char', kind: 'meta', symbol: '.', value: '.', codePoint: Number.NaN },
+ });
+ }
+ expressions.push(revampedNode);
+ if (missingEnd) {
+ expressions.push({
+ type: 'Repetition',
+ quantifier: { type: 'Quantifier', kind: '*', greedy: true },
+ expression: { type: 'Char', kind: 'meta', symbol: '.', value: '.', codePoint: Number.NaN },
+ });
+ expressions.push({ type: 'Assertion', kind: '$' });
+ }
+ return { type: 'Group', capturing: false, expression: { type: 'Alternative', expressions } };
+}
+function addMissingDotStarTraversal(astNode, isFirst, isLast, traversalResults) {
+ switch (astNode.type) {
+ case 'Char':
+ return astNode;
+ case 'Repetition':
+ return astNode;
+ case 'Quantifier':
+ throw new Error(`Wrongly defined AST tree, Quantifier nodes not supposed to be scanned!`);
+ case 'Alternative':
+ traversalResults.hasStart = true;
+ traversalResults.hasEnd = true;
+ return Object.assign(Object.assign({}, astNode), { expressions: astNode.expressions.map((node, index) => addMissingDotStarTraversalAddMissing(node, isFirst && index === 0, isLast && index === astNode.expressions.length - 1)) });
+ case 'CharacterClass':
+ return astNode;
+ case 'ClassRange':
+ return astNode;
+ case 'Group': {
+ return Object.assign(Object.assign({}, astNode), { expression: addMissingDotStarTraversal(astNode.expression, isFirst, isLast, traversalResults) });
+ }
+ case 'Disjunction': {
+ traversalResults.hasStart = true;
+ traversalResults.hasEnd = true;
+ return Object.assign(Object.assign({}, astNode), { left: astNode.left !== null ? addMissingDotStarTraversalAddMissing(astNode.left, isFirst, isLast) : null, right: astNode.right !== null ? addMissingDotStarTraversalAddMissing(astNode.right, isFirst, isLast) : null });
+ }
+ case 'Assertion': {
+ if (astNode.kind === '^' || astNode.kind === 'Lookahead') {
+ traversalResults.hasStart = true;
+ return astNode;
+ }
+ else if (astNode.kind === '$' || astNode.kind === 'Lookbehind') {
+ traversalResults.hasEnd = true;
+ return astNode;
+ }
+ else {
+ throw new Error(`Assertions of kind ${astNode.kind} not implemented yet!`);
+ }
+ }
+ case 'Backreference':
+ return astNode;
+ default:
+ throw raiseUnsupportedASTNode(astNode);
+ }
+}
+export function addMissingDotStar(astNode) {
+ return addMissingDotStarTraversalAddMissing(astNode, true, true);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/ShrinkBigInt.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/ShrinkBigInt.js
new file mode 100644
index 0000000000000000000000000000000000000000..0829de6b1581ac80f020f881d52b7f56af8633e1
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/ShrinkBigInt.js
@@ -0,0 +1,28 @@
+import { stream } from '../../../stream/Stream.js';
+import { Value } from '../../../check/arbitrary/definition/Value.js';
+import { BigInt } from '../../../utils/globals.js';
+function halveBigInt(n) {
+ return n / BigInt(2);
+}
+export function shrinkBigInt(current, target, tryTargetAsap) {
+ const realGap = current - target;
+ function* shrinkDecr() {
+ let previous = tryTargetAsap ? undefined : target;
+ const gap = tryTargetAsap ? realGap : halveBigInt(realGap);
+ for (let toremove = gap; toremove > 0; toremove = halveBigInt(toremove)) {
+ const next = current - toremove;
+ yield new Value(next, previous);
+ previous = next;
+ }
+ }
+ function* shrinkIncr() {
+ let previous = tryTargetAsap ? undefined : target;
+ const gap = tryTargetAsap ? realGap : halveBigInt(realGap);
+ for (let toremove = gap; toremove < 0; toremove = halveBigInt(toremove)) {
+ const next = current - toremove;
+ yield new Value(next, previous);
+ previous = next;
+ }
+ }
+ return realGap > 0 ? stream(shrinkDecr()) : stream(shrinkIncr());
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/ShrinkInteger.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/ShrinkInteger.js
new file mode 100644
index 0000000000000000000000000000000000000000..90846f73b118dc097f9819f9da33a38cef8c416b
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/ShrinkInteger.js
@@ -0,0 +1,32 @@
+import { Value } from '../../../check/arbitrary/definition/Value.js';
+import { stream } from '../../../stream/Stream.js';
+const safeMathCeil = Math.ceil;
+const safeMathFloor = Math.floor;
+function halvePosInteger(n) {
+ return safeMathFloor(n / 2);
+}
+function halveNegInteger(n) {
+ return safeMathCeil(n / 2);
+}
+export function shrinkInteger(current, target, tryTargetAsap) {
+ const realGap = current - target;
+ function* shrinkDecr() {
+ let previous = tryTargetAsap ? undefined : target;
+ const gap = tryTargetAsap ? realGap : halvePosInteger(realGap);
+ for (let toremove = gap; toremove > 0; toremove = halvePosInteger(toremove)) {
+ const next = toremove === realGap ? target : current - toremove;
+ yield new Value(next, previous);
+ previous = next;
+ }
+ }
+ function* shrinkIncr() {
+ let previous = tryTargetAsap ? undefined : target;
+ const gap = tryTargetAsap ? realGap : halveNegInteger(realGap);
+ for (let toremove = gap; toremove < 0; toremove = halveNegInteger(toremove)) {
+ const next = toremove === realGap ? target : current - toremove;
+ yield new Value(next, previous);
+ previous = next;
+ }
+ }
+ return realGap > 0 ? stream(shrinkDecr()) : stream(shrinkIncr());
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/SlicesForStringBuilder.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/SlicesForStringBuilder.js
new file mode 100644
index 0000000000000000000000000000000000000000..92aa3af195e7df3f8bc7b50009800bb931031e62
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/SlicesForStringBuilder.js
@@ -0,0 +1,78 @@
+import { safeGet, safePush, safeSet } from '../../../utils/globals.js';
+import { patternsToStringUnmapperIsValidLength } from '../mappers/PatternsToString.js';
+import { MaxLengthUpperBound } from './MaxLengthFromMinLength.js';
+import { tokenizeString } from './TokenizeString.js';
+const dangerousStrings = [
+ '__defineGetter__',
+ '__defineSetter__',
+ '__lookupGetter__',
+ '__lookupSetter__',
+ '__proto__',
+ 'constructor',
+ 'hasOwnProperty',
+ 'isPrototypeOf',
+ 'propertyIsEnumerable',
+ 'toLocaleString',
+ 'toString',
+ 'valueOf',
+ 'apply',
+ 'arguments',
+ 'bind',
+ 'call',
+ 'caller',
+ 'length',
+ 'name',
+ 'prototype',
+ 'key',
+ 'ref',
+];
+function computeCandidateStringLegacy(dangerous, charArbitrary, stringSplitter) {
+ let candidate;
+ try {
+ candidate = stringSplitter(dangerous);
+ }
+ catch (err) {
+ return undefined;
+ }
+ for (const entry of candidate) {
+ if (!charArbitrary.canShrinkWithoutContext(entry)) {
+ return undefined;
+ }
+ }
+ return candidate;
+}
+export function createSlicesForStringLegacy(charArbitrary, stringSplitter) {
+ const slicesForString = [];
+ for (const dangerous of dangerousStrings) {
+ const candidate = computeCandidateStringLegacy(dangerous, charArbitrary, stringSplitter);
+ if (candidate !== undefined) {
+ safePush(slicesForString, candidate);
+ }
+ }
+ return slicesForString;
+}
+const slicesPerArbitrary = new WeakMap();
+function createSlicesForStringNoConstraints(charArbitrary) {
+ const slicesForString = [];
+ for (const dangerous of dangerousStrings) {
+ const candidate = tokenizeString(charArbitrary, dangerous, 0, MaxLengthUpperBound);
+ if (candidate !== undefined) {
+ safePush(slicesForString, candidate);
+ }
+ }
+ return slicesForString;
+}
+export function createSlicesForString(charArbitrary, constraints) {
+ let slices = safeGet(slicesPerArbitrary, charArbitrary);
+ if (slices === undefined) {
+ slices = createSlicesForStringNoConstraints(charArbitrary);
+ safeSet(slicesPerArbitrary, charArbitrary, slices);
+ }
+ const slicesForConstraints = [];
+ for (const slice of slices) {
+ if (patternsToStringUnmapperIsValidLength(slice, constraints)) {
+ safePush(slicesForConstraints, slice);
+ }
+ }
+ return slicesForConstraints;
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/StrictlyEqualSet.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/StrictlyEqualSet.js
new file mode 100644
index 0000000000000000000000000000000000000000..851ffeea47f15c833baa7ac3134c0f8d8d4ecd16
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/StrictlyEqualSet.js
@@ -0,0 +1,29 @@
+import { safeAdd, safePush, Set } from '../../../utils/globals.js';
+const safeNumberIsNaN = Number.isNaN;
+export class StrictlyEqualSet {
+ constructor(selector) {
+ this.selector = selector;
+ this.selectedItemsExceptNaN = new Set();
+ this.data = [];
+ }
+ tryAdd(value) {
+ const selected = this.selector(value);
+ if (safeNumberIsNaN(selected)) {
+ safePush(this.data, value);
+ return true;
+ }
+ const sizeBefore = this.selectedItemsExceptNaN.size;
+ safeAdd(this.selectedItemsExceptNaN, selected);
+ if (sizeBefore !== this.selectedItemsExceptNaN.size) {
+ safePush(this.data, value);
+ return true;
+ }
+ return false;
+ }
+ size() {
+ return this.data.length;
+ }
+ getData() {
+ return this.data;
+ }
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/TextEscaper.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/TextEscaper.js
new file mode 100644
index 0000000000000000000000000000000000000000..bacc3429cf5f35e517054b525eef01b13fbdd8ff
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/TextEscaper.js
@@ -0,0 +1,6 @@
+export function escapeForTemplateString(originalText) {
+ return originalText.replace(/([$`\\])/g, '\\$1').replace(/\r/g, '\\r');
+}
+export function escapeForMultilineComments(originalText) {
+ return originalText.replace(/\*\//g, '*\\/');
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/ToggleFlags.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/ToggleFlags.js
new file mode 100644
index 0000000000000000000000000000000000000000..a5a1c46be4de09e3b455b09154a48d4ad9d7d4b7
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/ToggleFlags.js
@@ -0,0 +1,46 @@
+import { BigInt, safePush } from '../../../utils/globals.js';
+export function countToggledBits(n) {
+ let count = 0;
+ while (n > BigInt(0)) {
+ if (n & BigInt(1))
+ ++count;
+ n >>= BigInt(1);
+ }
+ return count;
+}
+export function computeNextFlags(flags, nextSize) {
+ const allowedMask = (BigInt(1) << BigInt(nextSize)) - BigInt(1);
+ const preservedFlags = flags & allowedMask;
+ let numMissingFlags = countToggledBits(flags - preservedFlags);
+ let nFlags = preservedFlags;
+ for (let mask = BigInt(1); mask <= allowedMask && numMissingFlags !== 0; mask <<= BigInt(1)) {
+ if (!(nFlags & mask)) {
+ nFlags |= mask;
+ --numMissingFlags;
+ }
+ }
+ return nFlags;
+}
+export function computeTogglePositions(chars, toggleCase) {
+ const positions = [];
+ for (let idx = chars.length - 1; idx !== -1; --idx) {
+ if (toggleCase(chars[idx]) !== chars[idx])
+ safePush(positions, idx);
+ }
+ return positions;
+}
+export function computeFlagsFromChars(untoggledChars, toggledChars, togglePositions) {
+ let flags = BigInt(0);
+ for (let idx = 0, mask = BigInt(1); idx !== togglePositions.length; ++idx, mask <<= BigInt(1)) {
+ if (untoggledChars[togglePositions[idx]] !== toggledChars[togglePositions[idx]]) {
+ flags |= mask;
+ }
+ }
+ return flags;
+}
+export function applyFlagsOnChars(chars, flags, togglePositions, toggleCase) {
+ for (let idx = 0, mask = BigInt(1); idx !== togglePositions.length; ++idx, mask <<= BigInt(1)) {
+ if (flags & mask)
+ chars[togglePositions[idx]] = toggleCase(chars[togglePositions[idx]]);
+ }
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/TokenizeRegex.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/TokenizeRegex.js
new file mode 100644
index 0000000000000000000000000000000000000000..dc7be7ae96b6dd73251a167514b4ff343edf7cee
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/TokenizeRegex.js
@@ -0,0 +1,320 @@
+import { safeIndexOf } from '../../../utils/globals.js';
+import { TokenizerBlockMode, readFrom } from './ReadRegex.js';
+const safeStringFromCodePoint = String.fromCodePoint;
+function safePop(tokens) {
+ const previous = tokens.pop();
+ if (previous === undefined) {
+ throw new Error('Unable to extract token preceeding the currently parsed one');
+ }
+ return previous;
+}
+function isDigit(char) {
+ return char >= '0' && char <= '9';
+}
+function simpleChar(char, escaped) {
+ return {
+ type: 'Char',
+ kind: 'simple',
+ symbol: char,
+ value: char,
+ codePoint: char.codePointAt(0) || -1,
+ escaped,
+ };
+}
+function metaEscapedChar(block, symbol) {
+ return {
+ type: 'Char',
+ kind: 'meta',
+ symbol,
+ value: block,
+ codePoint: symbol.codePointAt(0) || -1,
+ };
+}
+function toSingleToken(tokens, allowEmpty) {
+ if (tokens.length > 1) {
+ return {
+ type: 'Alternative',
+ expressions: tokens,
+ };
+ }
+ if (!allowEmpty && tokens.length === 0) {
+ throw new Error(`Unsupported no token`);
+ }
+ return tokens[0];
+}
+function blockToCharToken(block) {
+ if (block[0] === '\\') {
+ const next = block[1];
+ switch (next) {
+ case 'x': {
+ const allDigits = block.substring(2);
+ const codePoint = Number.parseInt(allDigits, 16);
+ const symbol = safeStringFromCodePoint(codePoint);
+ return { type: 'Char', kind: 'hex', symbol, value: block, codePoint };
+ }
+ case 'u': {
+ if (block === '\\u') {
+ return simpleChar('u', true);
+ }
+ const allDigits = block[2] === '{' ? block.substring(3, block.length - 1) : block.substring(2);
+ const codePoint = Number.parseInt(allDigits, 16);
+ const symbol = safeStringFromCodePoint(codePoint);
+ return { type: 'Char', kind: 'unicode', symbol, value: block, codePoint };
+ }
+ case '0': {
+ return metaEscapedChar(block, '\0');
+ }
+ case 'n': {
+ return metaEscapedChar(block, '\n');
+ }
+ case 'f': {
+ return metaEscapedChar(block, '\f');
+ }
+ case 'r': {
+ return metaEscapedChar(block, '\r');
+ }
+ case 't': {
+ return metaEscapedChar(block, '\t');
+ }
+ case 'v': {
+ return metaEscapedChar(block, '\v');
+ }
+ case 'w':
+ case 'W':
+ case 'd':
+ case 'D':
+ case 's':
+ case 'S':
+ case 'b':
+ case 'B': {
+ return { type: 'Char', kind: 'meta', symbol: undefined, value: block, codePoint: Number.NaN };
+ }
+ default: {
+ if (isDigit(next)) {
+ const allDigits = block.substring(1);
+ const codePoint = Number(allDigits);
+ const symbol = safeStringFromCodePoint(codePoint);
+ return { type: 'Char', kind: 'decimal', symbol, value: block, codePoint };
+ }
+ if (block.length > 2 && (next === 'p' || next === 'P')) {
+ throw new Error(`UnicodeProperty not implemented yet!`);
+ }
+ const char = block.substring(1);
+ return simpleChar(char, true);
+ }
+ }
+ }
+ return simpleChar(block);
+}
+function pushTokens(tokens, regexSource, unicodeMode, groups) {
+ let disjunctions = null;
+ for (let index = 0, block = readFrom(regexSource, index, unicodeMode, TokenizerBlockMode.Full); index !== regexSource.length; index += block.length, block = readFrom(regexSource, index, unicodeMode, TokenizerBlockMode.Full)) {
+ const firstInBlock = block[0];
+ switch (firstInBlock) {
+ case '|': {
+ if (disjunctions === null) {
+ disjunctions = [];
+ }
+ disjunctions.push(toSingleToken(tokens.splice(0), true) || null);
+ break;
+ }
+ case '.': {
+ tokens.push({ type: 'Char', kind: 'meta', symbol: block, value: block, codePoint: Number.NaN });
+ break;
+ }
+ case '*':
+ case '+': {
+ const previous = safePop(tokens);
+ tokens.push({
+ type: 'Repetition',
+ expression: previous,
+ quantifier: { type: 'Quantifier', kind: firstInBlock, greedy: true },
+ });
+ break;
+ }
+ case '?': {
+ const previous = safePop(tokens);
+ if (previous.type === 'Repetition') {
+ previous.quantifier.greedy = false;
+ tokens.push(previous);
+ }
+ else {
+ tokens.push({
+ type: 'Repetition',
+ expression: previous,
+ quantifier: { type: 'Quantifier', kind: firstInBlock, greedy: true },
+ });
+ }
+ break;
+ }
+ case '{': {
+ if (block === '{') {
+ tokens.push(simpleChar(block));
+ break;
+ }
+ const previous = safePop(tokens);
+ const quantifierText = block.substring(1, block.length - 1);
+ const quantifierTokens = quantifierText.split(',');
+ const from = Number(quantifierTokens[0]);
+ const to = quantifierTokens.length === 1
+ ? from
+ : quantifierTokens[1].length !== 0
+ ? Number(quantifierTokens[1])
+ : undefined;
+ tokens.push({
+ type: 'Repetition',
+ expression: previous,
+ quantifier: { type: 'Quantifier', kind: 'Range', greedy: true, from, to },
+ });
+ break;
+ }
+ case '[': {
+ const blockContent = block.substring(1, block.length - 1);
+ const subTokens = [];
+ let negative = undefined;
+ let previousWasSimpleDash = false;
+ for (let subIndex = 0, subBlock = readFrom(blockContent, subIndex, unicodeMode, TokenizerBlockMode.Character); subIndex !== blockContent.length; subIndex += subBlock.length,
+ subBlock = readFrom(blockContent, subIndex, unicodeMode, TokenizerBlockMode.Character)) {
+ if (subIndex === 0 && subBlock === '^') {
+ negative = true;
+ continue;
+ }
+ const newToken = blockToCharToken(subBlock);
+ if (subBlock === '-') {
+ subTokens.push(newToken);
+ previousWasSimpleDash = true;
+ }
+ else {
+ const operand1Token = subTokens.length >= 2 ? subTokens[subTokens.length - 2] : undefined;
+ if (previousWasSimpleDash && operand1Token !== undefined && operand1Token.type === 'Char') {
+ subTokens.pop();
+ subTokens.pop();
+ subTokens.push({ type: 'ClassRange', from: operand1Token, to: newToken });
+ }
+ else {
+ subTokens.push(newToken);
+ }
+ previousWasSimpleDash = false;
+ }
+ }
+ tokens.push({ type: 'CharacterClass', expressions: subTokens, negative });
+ break;
+ }
+ case '(': {
+ const blockContent = block.substring(1, block.length - 1);
+ const subTokens = [];
+ if (blockContent[0] === '?') {
+ if (blockContent[1] === ':') {
+ pushTokens(subTokens, blockContent.substring(2), unicodeMode, groups);
+ tokens.push({
+ type: 'Group',
+ capturing: false,
+ expression: toSingleToken(subTokens),
+ });
+ }
+ else if (blockContent[1] === '=' || blockContent[1] === '!') {
+ pushTokens(subTokens, blockContent.substring(2), unicodeMode, groups);
+ tokens.push({
+ type: 'Assertion',
+ kind: 'Lookahead',
+ negative: blockContent[1] === '!' ? true : undefined,
+ assertion: toSingleToken(subTokens),
+ });
+ }
+ else if (blockContent[1] === '<' && (blockContent[2] === '=' || blockContent[2] === '!')) {
+ pushTokens(subTokens, blockContent.substring(3), unicodeMode, groups);
+ tokens.push({
+ type: 'Assertion',
+ kind: 'Lookbehind',
+ negative: blockContent[2] === '!' ? true : undefined,
+ assertion: toSingleToken(subTokens),
+ });
+ }
+ else {
+ const chunks = blockContent.split('>');
+ if (chunks.length < 2 || chunks[0][1] !== '<') {
+ throw new Error(`Unsupported regex content found at ${JSON.stringify(block)}`);
+ }
+ const groupIndex = ++groups.lastIndex;
+ const nameRaw = chunks[0].substring(2);
+ groups.named.set(nameRaw, groupIndex);
+ pushTokens(subTokens, chunks.slice(1).join('>'), unicodeMode, groups);
+ tokens.push({
+ type: 'Group',
+ capturing: true,
+ nameRaw,
+ name: nameRaw,
+ number: groupIndex,
+ expression: toSingleToken(subTokens),
+ });
+ }
+ }
+ else {
+ const groupIndex = ++groups.lastIndex;
+ pushTokens(subTokens, blockContent, unicodeMode, groups);
+ tokens.push({
+ type: 'Group',
+ capturing: true,
+ number: groupIndex,
+ expression: toSingleToken(subTokens),
+ });
+ }
+ break;
+ }
+ default: {
+ if (block === '^') {
+ tokens.push({ type: 'Assertion', kind: block });
+ }
+ else if (block === '$') {
+ tokens.push({ type: 'Assertion', kind: block });
+ }
+ else if (block[0] === '\\' && isDigit(block[1])) {
+ const reference = Number(block.substring(1));
+ if (unicodeMode || reference <= groups.lastIndex) {
+ tokens.push({ type: 'Backreference', kind: 'number', number: reference, reference });
+ }
+ else {
+ tokens.push(blockToCharToken(block));
+ }
+ }
+ else if (block[0] === '\\' && block[1] === 'k' && block.length !== 2) {
+ const referenceRaw = block.substring(3, block.length - 1);
+ tokens.push({
+ type: 'Backreference',
+ kind: 'name',
+ number: groups.named.get(referenceRaw) || 0,
+ referenceRaw,
+ reference: referenceRaw,
+ });
+ }
+ else {
+ tokens.push(blockToCharToken(block));
+ }
+ break;
+ }
+ }
+ }
+ if (disjunctions !== null) {
+ disjunctions.push(toSingleToken(tokens.splice(0), true) || null);
+ let currentDisjunction = {
+ type: 'Disjunction',
+ left: disjunctions[0],
+ right: disjunctions[1],
+ };
+ for (let index = 2; index < disjunctions.length; ++index) {
+ currentDisjunction = {
+ type: 'Disjunction',
+ left: currentDisjunction,
+ right: disjunctions[index],
+ };
+ }
+ tokens.push(currentDisjunction);
+ }
+}
+export function tokenizeRegex(regex) {
+ const unicodeMode = safeIndexOf([...regex.flags], 'u') !== -1;
+ const regexSource = regex.source;
+ const tokens = [];
+ pushTokens(tokens, regexSource, unicodeMode, { lastIndex: 0, named: new Map() });
+ return toSingleToken(tokens);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/TokenizeString.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/TokenizeString.js
new file mode 100644
index 0000000000000000000000000000000000000000..695185f2af8a167bb226bd18506fa6c0b98c5632
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/TokenizeString.js
@@ -0,0 +1,34 @@
+import { safePop, safePush, safeSubstring } from '../../../utils/globals.js';
+export function tokenizeString(patternsArb, value, minLength, maxLength) {
+ if (value.length === 0) {
+ if (minLength > 0) {
+ return undefined;
+ }
+ return [];
+ }
+ if (maxLength <= 0) {
+ return undefined;
+ }
+ const stack = [{ endIndexChunks: 0, nextStartIndex: 1, chunks: [] }];
+ while (stack.length > 0) {
+ const last = safePop(stack);
+ for (let index = last.nextStartIndex; index <= value.length; ++index) {
+ const chunk = safeSubstring(value, last.endIndexChunks, index);
+ if (patternsArb.canShrinkWithoutContext(chunk)) {
+ const newChunks = [...last.chunks, chunk];
+ if (index === value.length) {
+ if (newChunks.length < minLength) {
+ break;
+ }
+ return newChunks;
+ }
+ safePush(stack, { endIndexChunks: last.endIndexChunks, nextStartIndex: index + 1, chunks: last.chunks });
+ if (newChunks.length < maxLength) {
+ safePush(stack, { endIndexChunks: index, nextStartIndex: index + 1, chunks: newChunks });
+ }
+ break;
+ }
+ }
+ }
+ return undefined;
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/ZipIterableIterators.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/ZipIterableIterators.js
new file mode 100644
index 0000000000000000000000000000000000000000..c0ddf9a8bca1bfb0c52371e04b821c02b8f02816
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/ZipIterableIterators.js
@@ -0,0 +1,27 @@
+function initZippedValues(its) {
+ const vs = [];
+ for (let index = 0; index !== its.length; ++index) {
+ vs.push(its[index].next());
+ }
+ return vs;
+}
+function nextZippedValues(its, vs) {
+ for (let index = 0; index !== its.length; ++index) {
+ vs[index] = its[index].next();
+ }
+}
+function isDoneZippedValues(vs) {
+ for (let index = 0; index !== vs.length; ++index) {
+ if (vs[index].done) {
+ return true;
+ }
+ }
+ return false;
+}
+export function* zipIterableIterators(...its) {
+ const vs = initZippedValues(its);
+ while (!isDoneZippedValues(vs)) {
+ yield vs.map((v) => v.value);
+ nextZippedValues(its, vs);
+ }
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/implementations/NoopSlicedGenerator.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/implementations/NoopSlicedGenerator.js
new file mode 100644
index 0000000000000000000000000000000000000000..621b252ba34e107e2a9e57add63b826292514f09
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/implementations/NoopSlicedGenerator.js
@@ -0,0 +1,13 @@
+export class NoopSlicedGenerator {
+ constructor(arb, mrng, biasFactor) {
+ this.arb = arb;
+ this.mrng = mrng;
+ this.biasFactor = biasFactor;
+ }
+ attemptExact() {
+ return;
+ }
+ next() {
+ return this.arb.generate(this.mrng, this.biasFactor);
+ }
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/implementations/SchedulerImplem.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/implementations/SchedulerImplem.js
new file mode 100644
index 0000000000000000000000000000000000000000..cbcb7fce0631c976c2d41f423577a6bbfe78ea27
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/implementations/SchedulerImplem.js
@@ -0,0 +1,192 @@
+import { escapeForTemplateString } from '../helpers/TextEscaper.js';
+import { cloneMethod } from '../../../check/symbols.js';
+import { stringify } from '../../../utils/stringify.js';
+const defaultSchedulerAct = (f) => f();
+export class SchedulerImplem {
+ constructor(act, taskSelector) {
+ this.act = act;
+ this.taskSelector = taskSelector;
+ this.lastTaskId = 0;
+ this.sourceTaskSelector = taskSelector.clone();
+ this.scheduledTasks = [];
+ this.triggeredTasks = [];
+ this.scheduledWatchers = [];
+ }
+ static buildLog(reportItem) {
+ return `[task\${${reportItem.taskId}}] ${reportItem.label.length !== 0 ? `${reportItem.schedulingType}::${reportItem.label}` : reportItem.schedulingType} ${reportItem.status}${reportItem.outputValue !== undefined ? ` with value ${escapeForTemplateString(reportItem.outputValue)}` : ''}`;
+ }
+ log(schedulingType, taskId, label, metadata, status, data) {
+ this.triggeredTasks.push({
+ status,
+ schedulingType,
+ taskId,
+ label,
+ metadata,
+ outputValue: data !== undefined ? stringify(data) : undefined,
+ });
+ }
+ scheduleInternal(schedulingType, label, task, metadata, customAct, thenTaskToBeAwaited) {
+ let trigger = null;
+ const taskId = ++this.lastTaskId;
+ const scheduledPromise = new Promise((resolve, reject) => {
+ trigger = () => {
+ (thenTaskToBeAwaited ? task.then(() => thenTaskToBeAwaited()) : task).then((data) => {
+ this.log(schedulingType, taskId, label, metadata, 'resolved', data);
+ return resolve(data);
+ }, (err) => {
+ this.log(schedulingType, taskId, label, metadata, 'rejected', err);
+ return reject(err);
+ });
+ };
+ });
+ this.scheduledTasks.push({
+ original: task,
+ scheduled: scheduledPromise,
+ trigger: trigger,
+ schedulingType,
+ taskId,
+ label,
+ metadata,
+ customAct,
+ });
+ if (this.scheduledWatchers.length !== 0) {
+ this.scheduledWatchers[0]();
+ }
+ return scheduledPromise;
+ }
+ schedule(task, label, metadata, customAct) {
+ return this.scheduleInternal('promise', label || '', task, metadata, customAct || defaultSchedulerAct);
+ }
+ scheduleFunction(asyncFunction, customAct) {
+ return (...args) => this.scheduleInternal('function', `${asyncFunction.name}(${args.map(stringify).join(',')})`, asyncFunction(...args), undefined, customAct || defaultSchedulerAct);
+ }
+ scheduleSequence(sequenceBuilders, customAct) {
+ const status = { done: false, faulty: false };
+ const dummyResolvedPromise = { then: (f) => f() };
+ let resolveSequenceTask = () => { };
+ const sequenceTask = new Promise((resolve) => (resolveSequenceTask = resolve));
+ sequenceBuilders
+ .reduce((previouslyScheduled, item) => {
+ const [builder, label, metadata] = typeof item === 'function' ? [item, item.name, undefined] : [item.builder, item.label, item.metadata];
+ return previouslyScheduled.then(() => {
+ const scheduled = this.scheduleInternal('sequence', label, dummyResolvedPromise, metadata, customAct || defaultSchedulerAct, () => builder());
+ scheduled.catch(() => {
+ status.faulty = true;
+ resolveSequenceTask();
+ });
+ return scheduled;
+ });
+ }, dummyResolvedPromise)
+ .then(() => {
+ status.done = true;
+ resolveSequenceTask();
+ }, () => {
+ });
+ return Object.assign(status, {
+ task: Promise.resolve(sequenceTask).then(() => {
+ return { done: status.done, faulty: status.faulty };
+ }),
+ });
+ }
+ count() {
+ return this.scheduledTasks.length;
+ }
+ internalWaitOne() {
+ if (this.scheduledTasks.length === 0) {
+ throw new Error('No task scheduled');
+ }
+ const taskIndex = this.taskSelector.nextTaskIndex(this.scheduledTasks);
+ const [scheduledTask] = this.scheduledTasks.splice(taskIndex, 1);
+ return scheduledTask.customAct(async () => {
+ scheduledTask.trigger();
+ try {
+ await scheduledTask.scheduled;
+ }
+ catch (_err) {
+ }
+ });
+ }
+ async waitOne(customAct) {
+ const waitAct = customAct || defaultSchedulerAct;
+ await this.act(() => waitAct(async () => await this.internalWaitOne()));
+ }
+ async waitAll(customAct) {
+ while (this.scheduledTasks.length > 0) {
+ await this.waitOne(customAct);
+ }
+ }
+ async waitFor(unscheduledTask, customAct) {
+ let taskResolved = false;
+ let awaiterPromise = null;
+ const awaiter = async () => {
+ while (!taskResolved && this.scheduledTasks.length > 0) {
+ await this.waitOne(customAct);
+ }
+ awaiterPromise = null;
+ };
+ const handleNotified = () => {
+ if (awaiterPromise !== null) {
+ return;
+ }
+ awaiterPromise = Promise.resolve().then(awaiter);
+ };
+ const clearAndReplaceWatcher = () => {
+ const handleNotifiedIndex = this.scheduledWatchers.indexOf(handleNotified);
+ if (handleNotifiedIndex !== -1) {
+ this.scheduledWatchers.splice(handleNotifiedIndex, 1);
+ }
+ if (handleNotifiedIndex === 0 && this.scheduledWatchers.length !== 0) {
+ this.scheduledWatchers[0]();
+ }
+ };
+ const rewrappedTask = unscheduledTask.then((ret) => {
+ taskResolved = true;
+ if (awaiterPromise === null) {
+ clearAndReplaceWatcher();
+ return ret;
+ }
+ return awaiterPromise.then(() => {
+ clearAndReplaceWatcher();
+ return ret;
+ });
+ }, (err) => {
+ taskResolved = true;
+ if (awaiterPromise === null) {
+ clearAndReplaceWatcher();
+ throw err;
+ }
+ return awaiterPromise.then(() => {
+ clearAndReplaceWatcher();
+ throw err;
+ });
+ });
+ if (this.scheduledTasks.length > 0 && this.scheduledWatchers.length === 0) {
+ handleNotified();
+ }
+ this.scheduledWatchers.push(handleNotified);
+ return rewrappedTask;
+ }
+ report() {
+ return [
+ ...this.triggeredTasks,
+ ...this.scheduledTasks.map((t) => ({
+ status: 'pending',
+ schedulingType: t.schedulingType,
+ taskId: t.taskId,
+ label: t.label,
+ metadata: t.metadata,
+ })),
+ ];
+ }
+ toString() {
+ return ('schedulerFor()`\n' +
+ this.report()
+ .map(SchedulerImplem.buildLog)
+ .map((log) => `-> ${log}`)
+ .join('\n') +
+ '`');
+ }
+ [cloneMethod]() {
+ return new SchedulerImplem(this.act, this.sourceTaskSelector);
+ }
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/implementations/SlicedBasedGenerator.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/implementations/SlicedBasedGenerator.js
new file mode 100644
index 0000000000000000000000000000000000000000..7ee91be4b160ad817c335ffcd5f1544b5fdc4bdb
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/implementations/SlicedBasedGenerator.js
@@ -0,0 +1,52 @@
+import { Value } from '../../../check/arbitrary/definition/Value.js';
+import { safePush } from '../../../utils/globals.js';
+const safeMathMin = Math.min;
+const safeMathMax = Math.max;
+export class SlicedBasedGenerator {
+ constructor(arb, mrng, slices, biasFactor) {
+ this.arb = arb;
+ this.mrng = mrng;
+ this.slices = slices;
+ this.biasFactor = biasFactor;
+ this.activeSliceIndex = 0;
+ this.nextIndexInSlice = 0;
+ this.lastIndexInSlice = -1;
+ }
+ attemptExact(targetLength) {
+ if (targetLength !== 0 && this.mrng.nextInt(1, this.biasFactor) === 1) {
+ const eligibleIndices = [];
+ for (let index = 0; index !== this.slices.length; ++index) {
+ const slice = this.slices[index];
+ if (slice.length === targetLength) {
+ safePush(eligibleIndices, index);
+ }
+ }
+ if (eligibleIndices.length === 0) {
+ return;
+ }
+ this.activeSliceIndex = eligibleIndices[this.mrng.nextInt(0, eligibleIndices.length - 1)];
+ this.nextIndexInSlice = 0;
+ this.lastIndexInSlice = targetLength - 1;
+ }
+ }
+ next() {
+ if (this.nextIndexInSlice <= this.lastIndexInSlice) {
+ return new Value(this.slices[this.activeSliceIndex][this.nextIndexInSlice++], undefined);
+ }
+ if (this.mrng.nextInt(1, this.biasFactor) !== 1) {
+ return this.arb.generate(this.mrng, this.biasFactor);
+ }
+ this.activeSliceIndex = this.mrng.nextInt(0, this.slices.length - 1);
+ const slice = this.slices[this.activeSliceIndex];
+ if (this.mrng.nextInt(1, this.biasFactor) !== 1) {
+ this.nextIndexInSlice = 1;
+ this.lastIndexInSlice = slice.length - 1;
+ return new Value(slice[0], undefined);
+ }
+ const rangeBoundaryA = this.mrng.nextInt(0, slice.length - 1);
+ const rangeBoundaryB = this.mrng.nextInt(0, slice.length - 1);
+ this.nextIndexInSlice = safeMathMin(rangeBoundaryA, rangeBoundaryB);
+ this.lastIndexInSlice = safeMathMax(rangeBoundaryA, rangeBoundaryB);
+ return new Value(slice[this.nextIndexInSlice++], undefined);
+ }
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/interfaces/CustomSet.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/interfaces/CustomSet.js
new file mode 100644
index 0000000000000000000000000000000000000000..cb0ff5c3b541f646105198ee23ac0fc3d805023e
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/interfaces/CustomSet.js
@@ -0,0 +1 @@
+export {};
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/interfaces/Scheduler.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/interfaces/Scheduler.js
new file mode 100644
index 0000000000000000000000000000000000000000..cb0ff5c3b541f646105198ee23ac0fc3d805023e
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/interfaces/Scheduler.js
@@ -0,0 +1 @@
+export {};
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/interfaces/SlicedGenerator.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/interfaces/SlicedGenerator.js
new file mode 100644
index 0000000000000000000000000000000000000000..cb0ff5c3b541f646105198ee23ac0fc3d805023e
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/interfaces/SlicedGenerator.js
@@ -0,0 +1 @@
+export {};
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/ArrayToMap.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/ArrayToMap.js
new file mode 100644
index 0000000000000000000000000000000000000000..9b769f3edf3434731442a8420283945579d818f5
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/ArrayToMap.js
@@ -0,0 +1,12 @@
+export function arrayToMapMapper(data) {
+ return new Map(data);
+}
+export function arrayToMapUnmapper(value) {
+ if (typeof value !== 'object' || value === null) {
+ throw new Error('Incompatible instance received: should be a non-null object');
+ }
+ if (!('constructor' in value) || value.constructor !== Map) {
+ throw new Error('Incompatible instance received: should be of exact type Map');
+ }
+ return Array.from(value);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/ArrayToSet.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/ArrayToSet.js
new file mode 100644
index 0000000000000000000000000000000000000000..c1b71f3030d5df2e008c99cba29590b4f3360466
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/ArrayToSet.js
@@ -0,0 +1,12 @@
+export function arrayToSetMapper(data) {
+ return new Set(data);
+}
+export function arrayToSetUnmapper(value) {
+ if (typeof value !== 'object' || value === null) {
+ throw new Error('Incompatible instance received: should be a non-null object');
+ }
+ if (!('constructor' in value) || value.constructor !== Set) {
+ throw new Error('Incompatible instance received: should be of exact type Set');
+ }
+ return Array.from(value);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/CharsToString.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/CharsToString.js
new file mode 100644
index 0000000000000000000000000000000000000000..7dfee8b41aa29bed9d4287665da53405f588066f
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/CharsToString.js
@@ -0,0 +1,10 @@
+import { safeJoin, safeSplit } from '../../../utils/globals.js';
+export function charsToStringMapper(tab) {
+ return safeJoin(tab, '');
+}
+export function charsToStringUnmapper(value) {
+ if (typeof value !== 'string') {
+ throw new Error('Cannot unmap the passed value');
+ }
+ return safeSplit(value, '');
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/CodePointsToString.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/CodePointsToString.js
new file mode 100644
index 0000000000000000000000000000000000000000..918407068f8f831956949fc7a1c0513c4a4adcc4
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/CodePointsToString.js
@@ -0,0 +1,10 @@
+import { safeJoin } from '../../../utils/globals.js';
+export function codePointsToStringMapper(tab) {
+ return safeJoin(tab, '');
+}
+export function codePointsToStringUnmapper(value) {
+ if (typeof value !== 'string') {
+ throw new Error('Cannot unmap the passed value');
+ }
+ return [...value];
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/EntitiesToIPv6.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/EntitiesToIPv6.js
new file mode 100644
index 0000000000000000000000000000000000000000..fe1d99a8191a5f8580d8a4424ca048a6055bba26
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/EntitiesToIPv6.js
@@ -0,0 +1,71 @@
+import { safeEndsWith, safeJoin, safeSlice, safeSplit, safeStartsWith, safeSubstring } from '../../../utils/globals.js';
+function readBh(value) {
+ if (value.length === 0)
+ return [];
+ else
+ return safeSplit(value, ':');
+}
+function extractEhAndL(value) {
+ const valueSplits = safeSplit(value, ':');
+ if (valueSplits.length >= 2 && valueSplits[valueSplits.length - 1].length <= 4) {
+ return [
+ safeSlice(valueSplits, 0, valueSplits.length - 2),
+ `${valueSplits[valueSplits.length - 2]}:${valueSplits[valueSplits.length - 1]}`,
+ ];
+ }
+ return [safeSlice(valueSplits, 0, valueSplits.length - 1), valueSplits[valueSplits.length - 1]];
+}
+export function fullySpecifiedMapper(data) {
+ return `${safeJoin(data[0], ':')}:${data[1]}`;
+}
+export function fullySpecifiedUnmapper(value) {
+ if (typeof value !== 'string')
+ throw new Error('Invalid type');
+ return extractEhAndL(value);
+}
+export function onlyTrailingMapper(data) {
+ return `::${safeJoin(data[0], ':')}:${data[1]}`;
+}
+export function onlyTrailingUnmapper(value) {
+ if (typeof value !== 'string')
+ throw new Error('Invalid type');
+ if (!safeStartsWith(value, '::'))
+ throw new Error('Invalid value');
+ return extractEhAndL(safeSubstring(value, 2));
+}
+export function multiTrailingMapper(data) {
+ return `${safeJoin(data[0], ':')}::${safeJoin(data[1], ':')}:${data[2]}`;
+}
+export function multiTrailingUnmapper(value) {
+ if (typeof value !== 'string')
+ throw new Error('Invalid type');
+ const [bhString, trailingString] = safeSplit(value, '::', 2);
+ const [eh, l] = extractEhAndL(trailingString);
+ return [readBh(bhString), eh, l];
+}
+export function multiTrailingMapperOne(data) {
+ return multiTrailingMapper([data[0], [data[1]], data[2]]);
+}
+export function multiTrailingUnmapperOne(value) {
+ const out = multiTrailingUnmapper(value);
+ return [out[0], safeJoin(out[1], ':'), out[2]];
+}
+export function singleTrailingMapper(data) {
+ return `${safeJoin(data[0], ':')}::${data[1]}`;
+}
+export function singleTrailingUnmapper(value) {
+ if (typeof value !== 'string')
+ throw new Error('Invalid type');
+ const [bhString, trailing] = safeSplit(value, '::', 2);
+ return [readBh(bhString), trailing];
+}
+export function noTrailingMapper(data) {
+ return `${safeJoin(data[0], ':')}::`;
+}
+export function noTrailingUnmapper(value) {
+ if (typeof value !== 'string')
+ throw new Error('Invalid type');
+ if (!safeEndsWith(value, '::'))
+ throw new Error('Invalid value');
+ return [readBh(safeSubstring(value, 0, value.length - 2))];
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/IndexToCharString.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/IndexToCharString.js
new file mode 100644
index 0000000000000000000000000000000000000000..8ca45120c030edc98b2c0348d7b6f4b9b3df04a6
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/IndexToCharString.js
@@ -0,0 +1,19 @@
+import { safeCharCodeAt } from '../../../utils/globals.js';
+export const indexToCharStringMapper = String.fromCodePoint;
+export function indexToCharStringUnmapper(c) {
+ if (typeof c !== 'string') {
+ throw new Error('Cannot unmap non-string');
+ }
+ if (c.length === 0 || c.length > 2) {
+ throw new Error('Cannot unmap string with more or less than one character');
+ }
+ const c1 = safeCharCodeAt(c, 0);
+ if (c.length === 1) {
+ return c1;
+ }
+ const c2 = safeCharCodeAt(c, 1);
+ if (c1 < 0xd800 || c1 > 0xdbff || c2 < 0xdc00 || c2 > 0xdfff) {
+ throw new Error('Cannot unmap invalid surrogate pairs');
+ }
+ return c.codePointAt(0);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/IndexToMappedConstant.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/IndexToMappedConstant.js
new file mode 100644
index 0000000000000000000000000000000000000000..959b9ebf8f0092692284d7a51c8e23561e60ce30
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/IndexToMappedConstant.js
@@ -0,0 +1,67 @@
+import { Error, Number, Map, safeMapGet, safeMapSet } from '../../../utils/globals.js';
+const safeObjectIs = Object.is;
+function buildDichotomyEntries(entries) {
+ let currentFrom = 0;
+ const dichotomyEntries = [];
+ for (const entry of entries) {
+ const from = currentFrom;
+ currentFrom = from + entry.num;
+ const to = currentFrom - 1;
+ dichotomyEntries.push({ from, to, entry });
+ }
+ return dichotomyEntries;
+}
+function findDichotomyEntry(dichotomyEntries, choiceIndex) {
+ let min = 0;
+ let max = dichotomyEntries.length;
+ while (max - min > 1) {
+ const mid = ~~((min + max) / 2);
+ if (choiceIndex < dichotomyEntries[mid].from) {
+ max = mid;
+ }
+ else {
+ min = mid;
+ }
+ }
+ return dichotomyEntries[min];
+}
+export function indexToMappedConstantMapperFor(entries) {
+ const dichotomyEntries = buildDichotomyEntries(entries);
+ return function indexToMappedConstantMapper(choiceIndex) {
+ const dichotomyEntry = findDichotomyEntry(dichotomyEntries, choiceIndex);
+ return dichotomyEntry.entry.build(choiceIndex - dichotomyEntry.from);
+ };
+}
+function buildReverseMapping(entries) {
+ const reverseMapping = { mapping: new Map(), negativeZeroIndex: undefined };
+ let choiceIndex = 0;
+ for (let entryIdx = 0; entryIdx !== entries.length; ++entryIdx) {
+ const entry = entries[entryIdx];
+ for (let idxInEntry = 0; idxInEntry !== entry.num; ++idxInEntry) {
+ const value = entry.build(idxInEntry);
+ if (value === 0 && 1 / value === Number.NEGATIVE_INFINITY) {
+ reverseMapping.negativeZeroIndex = choiceIndex;
+ }
+ else {
+ safeMapSet(reverseMapping.mapping, value, choiceIndex);
+ }
+ ++choiceIndex;
+ }
+ }
+ return reverseMapping;
+}
+export function indexToMappedConstantUnmapperFor(entries) {
+ let reverseMapping = null;
+ return function indexToMappedConstantUnmapper(value) {
+ if (reverseMapping === null) {
+ reverseMapping = buildReverseMapping(entries);
+ }
+ const choiceIndex = safeObjectIs(value, -0)
+ ? reverseMapping.negativeZeroIndex
+ : safeMapGet(reverseMapping.mapping, value);
+ if (choiceIndex === undefined) {
+ throw new Error('Unknown value encountered cannot be built using this mapToConstant');
+ }
+ return choiceIndex;
+ };
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/IndexToPrintableIndex.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/IndexToPrintableIndex.js
new file mode 100644
index 0000000000000000000000000000000000000000..f95ed7f5f49f7626c2385effa9a368963d9f4075
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/IndexToPrintableIndex.js
@@ -0,0 +1,14 @@
+export function indexToPrintableIndexMapper(v) {
+ if (v < 95)
+ return v + 0x20;
+ if (v <= 0x7e)
+ return v - 95;
+ return v;
+}
+export function indexToPrintableIndexUnmapper(v) {
+ if (v >= 0x20 && v <= 0x7e)
+ return v - 0x20;
+ if (v >= 0 && v <= 0x1f)
+ return v + 95;
+ return v;
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/KeyValuePairsToObject.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/KeyValuePairsToObject.js
new file mode 100644
index 0000000000000000000000000000000000000000..066539fb22b53e11dad857303c19a375f63adc8d
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/KeyValuePairsToObject.js
@@ -0,0 +1,48 @@
+import { Error, safeEvery } from '../../../utils/globals.js';
+const safeObjectCreate = Object.create;
+const safeObjectDefineProperty = Object.defineProperty;
+const safeObjectGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+const safeObjectGetPrototypeOf = Object.getPrototypeOf;
+const safeObjectGetOwnPropertySymbols = Object.getOwnPropertySymbols;
+const safeObjectGetOwnPropertyNames = Object.getOwnPropertyNames;
+const safeObjectEntries = Object.entries;
+export function keyValuePairsToObjectMapper(definition) {
+ const obj = definition[1] ? safeObjectCreate(null) : {};
+ for (const keyValue of definition[0]) {
+ safeObjectDefineProperty(obj, keyValue[0], {
+ enumerable: true,
+ configurable: true,
+ writable: true,
+ value: keyValue[1],
+ });
+ }
+ return obj;
+}
+function buildIsValidPropertyNameFilter(obj) {
+ return function isValidPropertyNameFilter(key) {
+ const descriptor = safeObjectGetOwnPropertyDescriptor(obj, key);
+ return (descriptor !== undefined &&
+ !!descriptor.configurable &&
+ !!descriptor.enumerable &&
+ !!descriptor.writable &&
+ descriptor.get === undefined &&
+ descriptor.set === undefined);
+ };
+}
+export function keyValuePairsToObjectUnmapper(value) {
+ if (typeof value !== 'object' || value === null) {
+ throw new Error('Incompatible instance received: should be a non-null object');
+ }
+ const hasNullPrototype = safeObjectGetPrototypeOf(value) === null;
+ const hasObjectPrototype = 'constructor' in value && value.constructor === Object;
+ if (!hasNullPrototype && !hasObjectPrototype) {
+ throw new Error('Incompatible instance received: should be of exact type Object');
+ }
+ if (safeObjectGetOwnPropertySymbols(value).length > 0) {
+ throw new Error('Incompatible instance received: should contain symbols');
+ }
+ if (!safeEvery(safeObjectGetOwnPropertyNames(value), buildIsValidPropertyNameFilter(value))) {
+ throw new Error('Incompatible instance received: should contain only c/e/w properties without get/set');
+ }
+ return [safeObjectEntries(value), hasNullPrototype];
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/NatToStringifiedNat.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/NatToStringifiedNat.js
new file mode 100644
index 0000000000000000000000000000000000000000..590e61566518f75662e59592f821cf4e3b24f274
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/NatToStringifiedNat.js
@@ -0,0 +1,33 @@
+import { safeNumberToString, safeSubstring } from '../../../utils/globals.js';
+const safeNumberParseInt = Number.parseInt;
+export function natToStringifiedNatMapper(options) {
+ const [style, v] = options;
+ switch (style) {
+ case 'oct':
+ return `0${safeNumberToString(v, 8)}`;
+ case 'hex':
+ return `0x${safeNumberToString(v, 16)}`;
+ case 'dec':
+ default:
+ return `${v}`;
+ }
+}
+export function tryParseStringifiedNat(stringValue, radix) {
+ const parsedNat = safeNumberParseInt(stringValue, radix);
+ if (safeNumberToString(parsedNat, radix) !== stringValue) {
+ throw new Error('Invalid value');
+ }
+ return parsedNat;
+}
+export function natToStringifiedNatUnmapper(value) {
+ if (typeof value !== 'string') {
+ throw new Error('Invalid type');
+ }
+ if (value.length >= 2 && value[0] === '0') {
+ if (value[1] === 'x') {
+ return ['hex', tryParseStringifiedNat(safeSubstring(value, 2), 16)];
+ }
+ return ['oct', tryParseStringifiedNat(safeSubstring(value, 1), 8)];
+ }
+ return ['dec', tryParseStringifiedNat(value, 10)];
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/NumberToPaddedEight.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/NumberToPaddedEight.js
new file mode 100644
index 0000000000000000000000000000000000000000..1d83b9645fb4561f97e8087167c35ebc0a1f34c9
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/NumberToPaddedEight.js
@@ -0,0 +1,17 @@
+import { safeNumberToString, safePadStart } from '../../../utils/globals.js';
+export function numberToPaddedEightMapper(n) {
+ return safePadStart(safeNumberToString(n, 16), 8, '0');
+}
+export function numberToPaddedEightUnmapper(value) {
+ if (typeof value !== 'string') {
+ throw new Error('Unsupported type');
+ }
+ if (value.length !== 8) {
+ throw new Error('Unsupported value: invalid length');
+ }
+ const n = parseInt(value, 16);
+ if (value !== numberToPaddedEightMapper(n)) {
+ throw new Error('Unsupported value: invalid content');
+ }
+ return n;
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/PaddedEightsToUuid.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/PaddedEightsToUuid.js
new file mode 100644
index 0000000000000000000000000000000000000000..1fc3efdf8a29b4a507db25a9f986037e90b950f7
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/PaddedEightsToUuid.js
@@ -0,0 +1,15 @@
+import { safeSubstring } from '../../../utils/globals.js';
+export function paddedEightsToUuidMapper(t) {
+ return `${t[0]}-${safeSubstring(t[1], 4)}-${safeSubstring(t[1], 0, 4)}-${safeSubstring(t[2], 0, 4)}-${safeSubstring(t[2], 4)}${t[3]}`;
+}
+const UuidRegex = /^([0-9a-f]{8})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{12})$/;
+export function paddedEightsToUuidUnmapper(value) {
+ if (typeof value !== 'string') {
+ throw new Error('Unsupported type');
+ }
+ const m = UuidRegex.exec(value);
+ if (m === null) {
+ throw new Error('Unsupported type');
+ }
+ return [m[1], m[3] + m[2], m[4] + safeSubstring(m[5], 0, 4), safeSubstring(m[5], 4)];
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/PartsToUrl.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/PartsToUrl.js
new file mode 100644
index 0000000000000000000000000000000000000000..20aa9ee5b149e7d114bb8778cf4c5e6dc8036311
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/PartsToUrl.js
@@ -0,0 +1,28 @@
+export function partsToUrlMapper(data) {
+ const [scheme, authority, path] = data;
+ const query = data[3] === null ? '' : `?${data[3]}`;
+ const fragments = data[4] === null ? '' : `#${data[4]}`;
+ return `${scheme}://${authority}${path}${query}${fragments}`;
+}
+const UrlSplitRegex = /^([[A-Za-z][A-Za-z0-9+.-]*):\/\/([^/?#]*)([^?#]*)(\?[A-Za-z0-9\-._~!$&'()*+,;=:@/?%]*)?(#[A-Za-z0-9\-._~!$&'()*+,;=:@/?%]*)?$/;
+export function partsToUrlUnmapper(value) {
+ if (typeof value !== 'string') {
+ throw new Error('Incompatible value received: type');
+ }
+ const m = UrlSplitRegex.exec(value);
+ if (m === null) {
+ throw new Error('Incompatible value received');
+ }
+ const scheme = m[1];
+ const authority = m[2];
+ const path = m[3];
+ const query = m[4];
+ const fragments = m[5];
+ return [
+ scheme,
+ authority,
+ path,
+ query !== undefined ? query.substring(1) : null,
+ fragments !== undefined ? fragments.substring(1) : null,
+ ];
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/PatternsToString.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/PatternsToString.js
new file mode 100644
index 0000000000000000000000000000000000000000..ab0d6fd21d062eeb698787cbf55000da3c862de9
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/PatternsToString.js
@@ -0,0 +1,27 @@
+import { MaxLengthUpperBound } from '../helpers/MaxLengthFromMinLength.js';
+import { safeJoin, Error } from '../../../utils/globals.js';
+import { tokenizeString } from '../helpers/TokenizeString.js';
+export function patternsToStringMapper(tab) {
+ return safeJoin(tab, '');
+}
+function minLengthFrom(constraints) {
+ return constraints.minLength !== undefined ? constraints.minLength : 0;
+}
+function maxLengthFrom(constraints) {
+ return constraints.maxLength !== undefined ? constraints.maxLength : MaxLengthUpperBound;
+}
+export function patternsToStringUnmapperIsValidLength(tokens, constraints) {
+ return minLengthFrom(constraints) <= tokens.length && tokens.length <= maxLengthFrom(constraints);
+}
+export function patternsToStringUnmapperFor(patternsArb, constraints) {
+ return function patternsToStringUnmapper(value) {
+ if (typeof value !== 'string') {
+ throw new Error('Unsupported value');
+ }
+ const tokens = tokenizeString(patternsArb, value, minLengthFrom(constraints), maxLengthFrom(constraints));
+ if (tokens === undefined) {
+ throw new Error('Unable to unmap received string');
+ }
+ return tokens;
+ };
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/SegmentsToPath.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/SegmentsToPath.js
new file mode 100644
index 0000000000000000000000000000000000000000..91c1052e4dd5038886ae2a5561b0dc97cf440f3b
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/SegmentsToPath.js
@@ -0,0 +1,13 @@
+import { safeJoin, safeMap, safeSplice, safeSplit } from '../../../utils/globals.js';
+export function segmentsToPathMapper(segments) {
+ return safeJoin(safeMap(segments, (v) => `/${v}`), '');
+}
+export function segmentsToPathUnmapper(value) {
+ if (typeof value !== 'string') {
+ throw new Error('Incompatible value received: type');
+ }
+ if (value.length !== 0 && value[0] !== '/') {
+ throw new Error('Incompatible value received: start');
+ }
+ return safeSplice(safeSplit(value, '/'), 1);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/StringToBase64.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/StringToBase64.js
new file mode 100644
index 0000000000000000000000000000000000000000..f247de5c7c729c536c87346568adf575b5b0107d
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/StringToBase64.js
@@ -0,0 +1,27 @@
+import { safeSubstring } from '../../../utils/globals.js';
+export function stringToBase64Mapper(s) {
+ switch (s.length % 4) {
+ case 0:
+ return s;
+ case 3:
+ return `${s}=`;
+ case 2:
+ return `${s}==`;
+ default:
+ return safeSubstring(s, 1);
+ }
+}
+export function stringToBase64Unmapper(value) {
+ if (typeof value !== 'string' || value.length % 4 !== 0) {
+ throw new Error('Invalid string received');
+ }
+ const lastTrailingIndex = value.indexOf('=');
+ if (lastTrailingIndex === -1) {
+ return value;
+ }
+ const numTrailings = value.length - lastTrailingIndex;
+ if (numTrailings > 2) {
+ throw new Error('Cannot unmap the passed value');
+ }
+ return safeSubstring(value, 0, lastTrailingIndex);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/TimeToDate.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/TimeToDate.js
new file mode 100644
index 0000000000000000000000000000000000000000..74d0f70338c7b183729a00a1c9579ab81127b29e
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/TimeToDate.js
@@ -0,0 +1,23 @@
+import { Date, Error, safeGetTime } from '../../../utils/globals.js';
+const safeNaN = Number.NaN;
+const safeNumberIsNaN = Number.isNaN;
+export function timeToDateMapper(time) {
+ return new Date(time);
+}
+export function timeToDateUnmapper(value) {
+ if (!(value instanceof Date) || value.constructor !== Date) {
+ throw new Error('Not a valid value for date unmapper');
+ }
+ return safeGetTime(value);
+}
+export function timeToDateMapperWithNaN(valueForNaN) {
+ return (time) => {
+ return time === valueForNaN ? new Date(safeNaN) : timeToDateMapper(time);
+ };
+}
+export function timeToDateUnmapperWithNaN(valueForNaN) {
+ return (value) => {
+ const time = timeToDateUnmapper(value);
+ return safeNumberIsNaN(time) ? valueForNaN : time;
+ };
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/UintToBase32String.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/UintToBase32String.js
new file mode 100644
index 0000000000000000000000000000000000000000..bb7943221ee59f5b31adf342b5d0f9c226221244
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/UintToBase32String.js
@@ -0,0 +1,106 @@
+import { Error, String } from '../../../utils/globals.js';
+const encodeSymbolLookupTable = {
+ 10: 'A',
+ 11: 'B',
+ 12: 'C',
+ 13: 'D',
+ 14: 'E',
+ 15: 'F',
+ 16: 'G',
+ 17: 'H',
+ 18: 'J',
+ 19: 'K',
+ 20: 'M',
+ 21: 'N',
+ 22: 'P',
+ 23: 'Q',
+ 24: 'R',
+ 25: 'S',
+ 26: 'T',
+ 27: 'V',
+ 28: 'W',
+ 29: 'X',
+ 30: 'Y',
+ 31: 'Z',
+};
+const decodeSymbolLookupTable = {
+ '0': 0,
+ '1': 1,
+ '2': 2,
+ '3': 3,
+ '4': 4,
+ '5': 5,
+ '6': 6,
+ '7': 7,
+ '8': 8,
+ '9': 9,
+ A: 10,
+ B: 11,
+ C: 12,
+ D: 13,
+ E: 14,
+ F: 15,
+ G: 16,
+ H: 17,
+ J: 18,
+ K: 19,
+ M: 20,
+ N: 21,
+ P: 22,
+ Q: 23,
+ R: 24,
+ S: 25,
+ T: 26,
+ V: 27,
+ W: 28,
+ X: 29,
+ Y: 30,
+ Z: 31,
+};
+function encodeSymbol(symbol) {
+ return symbol < 10 ? String(symbol) : encodeSymbolLookupTable[symbol];
+}
+function pad(value, paddingLength) {
+ let extraPadding = '';
+ while (value.length + extraPadding.length < paddingLength) {
+ extraPadding += '0';
+ }
+ return extraPadding + value;
+}
+function smallUintToBase32StringMapper(num) {
+ let base32Str = '';
+ for (let remaining = num; remaining !== 0;) {
+ const next = remaining >> 5;
+ const current = remaining - (next << 5);
+ base32Str = encodeSymbol(current) + base32Str;
+ remaining = next;
+ }
+ return base32Str;
+}
+export function uintToBase32StringMapper(num, paddingLength) {
+ const head = ~~(num / 0x40000000);
+ const tail = num & 0x3fffffff;
+ return pad(smallUintToBase32StringMapper(head), paddingLength - 6) + pad(smallUintToBase32StringMapper(tail), 6);
+}
+export function paddedUintToBase32StringMapper(paddingLength) {
+ return function padded(num) {
+ return uintToBase32StringMapper(num, paddingLength);
+ };
+}
+export function uintToBase32StringUnmapper(value) {
+ if (typeof value !== 'string') {
+ throw new Error('Unsupported type');
+ }
+ let accumulated = 0;
+ let power = 1;
+ for (let index = value.length - 1; index >= 0; --index) {
+ const char = value[index];
+ const numericForChar = decodeSymbolLookupTable[char];
+ if (numericForChar === undefined) {
+ throw new Error('Unsupported type');
+ }
+ accumulated += numericForChar * power;
+ power *= 32;
+ }
+ return accumulated;
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/UnboxedToBoxed.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/UnboxedToBoxed.js
new file mode 100644
index 0000000000000000000000000000000000000000..b3ebf4dbd7d093b681ee09697921cf4e40acf66a
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/UnboxedToBoxed.js
@@ -0,0 +1,21 @@
+import { Boolean, Number, String } from '../../../utils/globals.js';
+export function unboxedToBoxedMapper(value) {
+ switch (typeof value) {
+ case 'boolean':
+ return new Boolean(value);
+ case 'number':
+ return new Number(value);
+ case 'string':
+ return new String(value);
+ default:
+ return value;
+ }
+}
+export function unboxedToBoxedUnmapper(value) {
+ if (typeof value !== 'object' || value === null || !('constructor' in value)) {
+ return value;
+ }
+ return value.constructor === Boolean || value.constructor === Number || value.constructor === String
+ ? value.valueOf()
+ : value;
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/ValuesAndSeparateKeysToObject.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/ValuesAndSeparateKeysToObject.js
new file mode 100644
index 0000000000000000000000000000000000000000..3756e257adb6883aee41a19a48549bbc05b53dd8
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/ValuesAndSeparateKeysToObject.js
@@ -0,0 +1,59 @@
+import { safePush } from '../../../utils/globals.js';
+const safeObjectCreate = Object.create;
+const safeObjectDefineProperty = Object.defineProperty;
+const safeObjectGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+const safeObjectGetOwnPropertyNames = Object.getOwnPropertyNames;
+const safeObjectGetOwnPropertySymbols = Object.getOwnPropertySymbols;
+export function buildValuesAndSeparateKeysToObjectMapper(keys, noKeyValue) {
+ return function valuesAndSeparateKeysToObjectMapper(definition) {
+ const obj = definition[1] ? safeObjectCreate(null) : {};
+ for (let idx = 0; idx !== keys.length; ++idx) {
+ const valueWrapper = definition[0][idx];
+ if (valueWrapper !== noKeyValue) {
+ safeObjectDefineProperty(obj, keys[idx], {
+ value: valueWrapper,
+ configurable: true,
+ enumerable: true,
+ writable: true,
+ });
+ }
+ }
+ return obj;
+ };
+}
+export function buildValuesAndSeparateKeysToObjectUnmapper(keys, noKeyValue) {
+ return function valuesAndSeparateKeysToObjectUnmapper(value) {
+ if (typeof value !== 'object' || value === null) {
+ throw new Error('Incompatible instance received: should be a non-null object');
+ }
+ const hasNullPrototype = Object.getPrototypeOf(value) === null;
+ const hasObjectPrototype = 'constructor' in value && value.constructor === Object;
+ if (!hasNullPrototype && !hasObjectPrototype) {
+ throw new Error('Incompatible instance received: should be of exact type Object');
+ }
+ let extractedPropertiesCount = 0;
+ const extractedValues = [];
+ for (let idx = 0; idx !== keys.length; ++idx) {
+ const descriptor = safeObjectGetOwnPropertyDescriptor(value, keys[idx]);
+ if (descriptor !== undefined) {
+ if (!descriptor.configurable || !descriptor.enumerable || !descriptor.writable) {
+ throw new Error('Incompatible instance received: should contain only c/e/w properties');
+ }
+ if (descriptor.get !== undefined || descriptor.set !== undefined) {
+ throw new Error('Incompatible instance received: should contain only no get/set properties');
+ }
+ ++extractedPropertiesCount;
+ safePush(extractedValues, descriptor.value);
+ }
+ else {
+ safePush(extractedValues, noKeyValue);
+ }
+ }
+ const namePropertiesCount = safeObjectGetOwnPropertyNames(value).length;
+ const symbolPropertiesCount = safeObjectGetOwnPropertySymbols(value).length;
+ if (extractedPropertiesCount !== namePropertiesCount + symbolPropertiesCount) {
+ throw new Error('Incompatible instance received: should not contain extra properties');
+ }
+ return [extractedValues, hasNullPrototype];
+ };
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/VersionsApplierForUuid.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/VersionsApplierForUuid.js
new file mode 100644
index 0000000000000000000000000000000000000000..e1eeb24b8f90083fe9bf6ec7925bf262d1465192
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/VersionsApplierForUuid.js
@@ -0,0 +1,26 @@
+import { Error, safeSubstring } from '../../../utils/globals.js';
+const quickNumberToHexaString = '0123456789abcdef';
+export function buildVersionsAppliersForUuid(versions) {
+ const mapping = {};
+ const reversedMapping = {};
+ for (let index = 0; index !== versions.length; ++index) {
+ const from = quickNumberToHexaString[index];
+ const to = quickNumberToHexaString[versions[index]];
+ mapping[from] = to;
+ reversedMapping[to] = from;
+ }
+ function versionsApplierMapper(value) {
+ return mapping[value[0]] + safeSubstring(value, 1);
+ }
+ function versionsApplierUnmapper(value) {
+ if (typeof value !== 'string') {
+ throw new Error('Cannot produce non-string values');
+ }
+ const rev = reversedMapping[value[0]];
+ if (rev === undefined) {
+ throw new Error('Cannot produce strings not starting by the version in hexa code');
+ }
+ return rev + safeSubstring(value, 1);
+ }
+ return { versionsApplierMapper, versionsApplierUnmapper };
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/WordsToLorem.js b/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/WordsToLorem.js
new file mode 100644
index 0000000000000000000000000000000000000000..f7727a35620f77c47755ac5279f09625e21a2df9
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/WordsToLorem.js
@@ -0,0 +1,67 @@
+import { safeJoin, safeMap, safePush, safeSplit, safeSubstring, safeToLowerCase, safeToUpperCase, } from '../../../utils/globals.js';
+export function wordsToJoinedStringMapper(words) {
+ return safeJoin(safeMap(words, (w) => (w[w.length - 1] === ',' ? safeSubstring(w, 0, w.length - 1) : w)), ' ');
+}
+export function wordsToJoinedStringUnmapperFor(wordsArbitrary) {
+ return function wordsToJoinedStringUnmapper(value) {
+ if (typeof value !== 'string') {
+ throw new Error('Unsupported type');
+ }
+ const words = [];
+ for (const candidate of safeSplit(value, ' ')) {
+ if (wordsArbitrary.canShrinkWithoutContext(candidate))
+ safePush(words, candidate);
+ else if (wordsArbitrary.canShrinkWithoutContext(candidate + ','))
+ safePush(words, candidate + ',');
+ else
+ throw new Error('Unsupported word');
+ }
+ return words;
+ };
+}
+export function wordsToSentenceMapper(words) {
+ let sentence = safeJoin(words, ' ');
+ if (sentence[sentence.length - 1] === ',') {
+ sentence = safeSubstring(sentence, 0, sentence.length - 1);
+ }
+ return safeToUpperCase(sentence[0]) + safeSubstring(sentence, 1) + '.';
+}
+export function wordsToSentenceUnmapperFor(wordsArbitrary) {
+ return function wordsToSentenceUnmapper(value) {
+ if (typeof value !== 'string') {
+ throw new Error('Unsupported type');
+ }
+ if (value.length < 2 ||
+ value[value.length - 1] !== '.' ||
+ value[value.length - 2] === ',' ||
+ safeToUpperCase(safeToLowerCase(value[0])) !== value[0]) {
+ throw new Error('Unsupported value');
+ }
+ const adaptedValue = safeToLowerCase(value[0]) + safeSubstring(value, 1, value.length - 1);
+ const words = [];
+ const candidates = safeSplit(adaptedValue, ' ');
+ for (let idx = 0; idx !== candidates.length; ++idx) {
+ const candidate = candidates[idx];
+ if (wordsArbitrary.canShrinkWithoutContext(candidate))
+ safePush(words, candidate);
+ else if (idx === candidates.length - 1 && wordsArbitrary.canShrinkWithoutContext(candidate + ','))
+ safePush(words, candidate + ',');
+ else
+ throw new Error('Unsupported word');
+ }
+ return words;
+ };
+}
+export function sentencesToParagraphMapper(sentences) {
+ return safeJoin(sentences, ' ');
+}
+export function sentencesToParagraphUnmapper(value) {
+ if (typeof value !== 'string') {
+ throw new Error('Unsupported type');
+ }
+ const sentences = safeSplit(value, '. ');
+ for (let idx = 0; idx < sentences.length - 1; ++idx) {
+ sentences[idx] += '.';
+ }
+ return sentences;
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/_shared/StringSharedConstraints.js b/node_modules/fast-check/lib/esm/arbitrary/_shared/StringSharedConstraints.js
new file mode 100644
index 0000000000000000000000000000000000000000..cb0ff5c3b541f646105198ee23ac0fc3d805023e
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/_shared/StringSharedConstraints.js
@@ -0,0 +1 @@
+export {};
diff --git a/node_modules/fast-check/lib/esm/arbitrary/anything.js b/node_modules/fast-check/lib/esm/arbitrary/anything.js
new file mode 100644
index 0000000000000000000000000000000000000000..d9224d85db779b51cdc9f187ebfc4618fc984db5
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/anything.js
@@ -0,0 +1,6 @@
+import { anyArbitraryBuilder } from './_internals/builders/AnyArbitraryBuilder.js';
+import { toQualifiedObjectConstraints } from './_internals/helpers/QualifiedObjectConstraints.js';
+function anything(constraints) {
+ return anyArbitraryBuilder(toQualifiedObjectConstraints(constraints));
+}
+export { anything };
diff --git a/node_modules/fast-check/lib/esm/arbitrary/array.js b/node_modules/fast-check/lib/esm/arbitrary/array.js
new file mode 100644
index 0000000000000000000000000000000000000000..343f805a71a4e0803034a4a442a480303757712d
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/array.js
@@ -0,0 +1,14 @@
+import { ArrayArbitrary } from './_internals/ArrayArbitrary.js';
+import { MaxLengthUpperBound, maxGeneratedLengthFromSizeForArbitrary, } from './_internals/helpers/MaxLengthFromMinLength.js';
+function array(arb, constraints = {}) {
+ const size = constraints.size;
+ const minLength = constraints.minLength || 0;
+ const maxLengthOrUnset = constraints.maxLength;
+ const depthIdentifier = constraints.depthIdentifier;
+ const maxLength = maxLengthOrUnset !== undefined ? maxLengthOrUnset : MaxLengthUpperBound;
+ const specifiedMaxLength = maxLengthOrUnset !== undefined;
+ const maxGeneratedLength = maxGeneratedLengthFromSizeForArbitrary(size, minLength, maxLength, specifiedMaxLength);
+ const customSlices = constraints.experimentalCustomSlices || [];
+ return new ArrayArbitrary(arb, minLength, maxGeneratedLength, maxLength, depthIdentifier, undefined, customSlices);
+}
+export { array };
diff --git a/node_modules/fast-check/lib/esm/arbitrary/ascii.js b/node_modules/fast-check/lib/esm/arbitrary/ascii.js
new file mode 100644
index 0000000000000000000000000000000000000000..14ec66f7b7b84e2b915df9252ace6d83d27c8c97
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/ascii.js
@@ -0,0 +1,5 @@
+import { buildCharacterArbitrary } from './_internals/builders/CharacterArbitraryBuilder.js';
+import { indexToPrintableIndexMapper, indexToPrintableIndexUnmapper } from './_internals/mappers/IndexToPrintableIndex.js';
+export function ascii() {
+ return buildCharacterArbitrary(0x00, 0x7f, indexToPrintableIndexMapper, indexToPrintableIndexUnmapper);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/asciiString.js b/node_modules/fast-check/lib/esm/arbitrary/asciiString.js
new file mode 100644
index 0000000000000000000000000000000000000000..9192bf439af668a2d490daa1aeefefc21710fbcb
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/asciiString.js
@@ -0,0 +1,13 @@
+import { array } from './array.js';
+import { ascii } from './ascii.js';
+import { codePointsToStringMapper, codePointsToStringUnmapper } from './_internals/mappers/CodePointsToString.js';
+import { createSlicesForStringLegacy } from './_internals/helpers/SlicesForStringBuilder.js';
+const safeObjectAssign = Object.assign;
+export function asciiString(constraints = {}) {
+ const charArbitrary = ascii();
+ const experimentalCustomSlices = createSlicesForStringLegacy(charArbitrary, codePointsToStringUnmapper);
+ const enrichedConstraints = safeObjectAssign(safeObjectAssign({}, constraints), {
+ experimentalCustomSlices,
+ });
+ return array(charArbitrary, enrichedConstraints).map(codePointsToStringMapper, codePointsToStringUnmapper);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/base64.js b/node_modules/fast-check/lib/esm/arbitrary/base64.js
new file mode 100644
index 0000000000000000000000000000000000000000..960c2f6374505f85bd57486bd06edc8383794858
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/base64.js
@@ -0,0 +1,22 @@
+import { buildCharacterArbitrary } from './_internals/builders/CharacterArbitraryBuilder.js';
+function base64Mapper(v) {
+ if (v < 26)
+ return v + 65;
+ if (v < 52)
+ return v + 97 - 26;
+ if (v < 62)
+ return v + 48 - 52;
+ return v === 62 ? 43 : 47;
+}
+function base64Unmapper(v) {
+ if (v >= 65 && v <= 90)
+ return v - 65;
+ if (v >= 97 && v <= 122)
+ return v - 97 + 26;
+ if (v >= 48 && v <= 57)
+ return v - 48 + 52;
+ return v === 43 ? 62 : v === 47 ? 63 : -1;
+}
+export function base64() {
+ return buildCharacterArbitrary(0, 63, base64Mapper, base64Unmapper);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/base64String.js b/node_modules/fast-check/lib/esm/arbitrary/base64String.js
new file mode 100644
index 0000000000000000000000000000000000000000..e932426bfb1b7bd06414577653b2ade830b74c85
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/base64String.js
@@ -0,0 +1,30 @@
+import { array } from './array.js';
+import { base64 } from './base64.js';
+import { MaxLengthUpperBound } from './_internals/helpers/MaxLengthFromMinLength.js';
+import { codePointsToStringMapper, codePointsToStringUnmapper } from './_internals/mappers/CodePointsToString.js';
+import { stringToBase64Mapper, stringToBase64Unmapper } from './_internals/mappers/StringToBase64.js';
+import { createSlicesForStringLegacy } from './_internals/helpers/SlicesForStringBuilder.js';
+function base64String(constraints = {}) {
+ const { minLength: unscaledMinLength = 0, maxLength: unscaledMaxLength = MaxLengthUpperBound, size } = constraints;
+ const minLength = unscaledMinLength + 3 - ((unscaledMinLength + 3) % 4);
+ const maxLength = unscaledMaxLength - (unscaledMaxLength % 4);
+ const requestedSize = constraints.maxLength === undefined && size === undefined ? '=' : size;
+ if (minLength > maxLength)
+ throw new Error('Minimal length should be inferior or equal to maximal length');
+ if (minLength % 4 !== 0)
+ throw new Error('Minimal length of base64 strings must be a multiple of 4');
+ if (maxLength % 4 !== 0)
+ throw new Error('Maximal length of base64 strings must be a multiple of 4');
+ const charArbitrary = base64();
+ const experimentalCustomSlices = createSlicesForStringLegacy(charArbitrary, codePointsToStringUnmapper);
+ const enrichedConstraints = {
+ minLength,
+ maxLength,
+ size: requestedSize,
+ experimentalCustomSlices,
+ };
+ return array(charArbitrary, enrichedConstraints)
+ .map(codePointsToStringMapper, codePointsToStringUnmapper)
+ .map(stringToBase64Mapper, stringToBase64Unmapper);
+}
+export { base64String };
diff --git a/node_modules/fast-check/lib/esm/arbitrary/bigInt.js b/node_modules/fast-check/lib/esm/arbitrary/bigInt.js
new file mode 100644
index 0000000000000000000000000000000000000000..dc86757c9e736afb82bf0b49d9dfbb0664ffb021
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/bigInt.js
@@ -0,0 +1,31 @@
+import { BigInt } from '../utils/globals.js';
+import { BigIntArbitrary } from './_internals/BigIntArbitrary.js';
+function buildCompleteBigIntConstraints(constraints) {
+ const DefaultPow = 256;
+ const DefaultMin = BigInt(-1) << BigInt(DefaultPow - 1);
+ const DefaultMax = (BigInt(1) << BigInt(DefaultPow - 1)) - BigInt(1);
+ const min = constraints.min;
+ const max = constraints.max;
+ return {
+ min: min !== undefined ? min : DefaultMin - (max !== undefined && max < BigInt(0) ? max * max : BigInt(0)),
+ max: max !== undefined ? max : DefaultMax + (min !== undefined && min > BigInt(0) ? min * min : BigInt(0)),
+ };
+}
+function extractBigIntConstraints(args) {
+ if (args[0] === undefined) {
+ return {};
+ }
+ if (args[1] === undefined) {
+ const constraints = args[0];
+ return constraints;
+ }
+ return { min: args[0], max: args[1] };
+}
+function bigInt(...args) {
+ const constraints = buildCompleteBigIntConstraints(extractBigIntConstraints(args));
+ if (constraints.min > constraints.max) {
+ throw new Error('fc.bigInt expects max to be greater than or equal to min');
+ }
+ return new BigIntArbitrary(constraints.min, constraints.max);
+}
+export { bigInt };
diff --git a/node_modules/fast-check/lib/esm/arbitrary/bigInt64Array.js b/node_modules/fast-check/lib/esm/arbitrary/bigInt64Array.js
new file mode 100644
index 0000000000000000000000000000000000000000..390f1b1e298f324c700defcf0811d6e6cdd19c3f
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/bigInt64Array.js
@@ -0,0 +1,6 @@
+import { BigInt, BigInt64Array } from '../utils/globals.js';
+import { bigInt } from './bigInt.js';
+import { typedIntArrayArbitraryArbitraryBuilder } from './_internals/builders/TypedIntArrayArbitraryBuilder.js';
+export function bigInt64Array(constraints = {}) {
+ return typedIntArrayArbitraryArbitraryBuilder(constraints, BigInt('-9223372036854775808'), BigInt('9223372036854775807'), BigInt64Array, bigInt);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/bigIntN.js b/node_modules/fast-check/lib/esm/arbitrary/bigIntN.js
new file mode 100644
index 0000000000000000000000000000000000000000..28fd030cce134745ce557983b8ac061f2a388fe4
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/bigIntN.js
@@ -0,0 +1,10 @@
+import { BigInt } from '../utils/globals.js';
+import { BigIntArbitrary } from './_internals/BigIntArbitrary.js';
+export function bigIntN(n) {
+ if (n < 1) {
+ throw new Error('fc.bigIntN expects requested number of bits to be superior or equal to 1');
+ }
+ const min = BigInt(-1) << BigInt(n - 1);
+ const max = (BigInt(1) << BigInt(n - 1)) - BigInt(1);
+ return new BigIntArbitrary(min, max);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/bigUint.js b/node_modules/fast-check/lib/esm/arbitrary/bigUint.js
new file mode 100644
index 0000000000000000000000000000000000000000..3746f01260495f52bf68c7fbae1c5c35f90d789c
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/bigUint.js
@@ -0,0 +1,14 @@
+import { BigInt } from '../utils/globals.js';
+import { BigIntArbitrary } from './_internals/BigIntArbitrary.js';
+function computeDefaultMax() {
+ return (BigInt(1) << BigInt(256)) - BigInt(1);
+}
+function bigUint(constraints) {
+ const requestedMax = typeof constraints === 'object' ? constraints.max : constraints;
+ const max = requestedMax !== undefined ? requestedMax : computeDefaultMax();
+ if (max < 0) {
+ throw new Error('fc.bigUint expects max to be greater than or equal to zero');
+ }
+ return new BigIntArbitrary(BigInt(0), max);
+}
+export { bigUint };
diff --git a/node_modules/fast-check/lib/esm/arbitrary/bigUint64Array.js b/node_modules/fast-check/lib/esm/arbitrary/bigUint64Array.js
new file mode 100644
index 0000000000000000000000000000000000000000..4f8fa1dff940e6e21c7d23ff5c59c81f1b699c77
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/bigUint64Array.js
@@ -0,0 +1,6 @@
+import { BigInt, BigUint64Array } from '../utils/globals.js';
+import { bigInt } from './bigInt.js';
+import { typedIntArrayArbitraryArbitraryBuilder } from './_internals/builders/TypedIntArrayArbitraryBuilder.js';
+export function bigUint64Array(constraints = {}) {
+ return typedIntArrayArbitraryArbitraryBuilder(constraints, BigInt(0), BigInt('18446744073709551615'), BigUint64Array, bigInt);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/bigUintN.js b/node_modules/fast-check/lib/esm/arbitrary/bigUintN.js
new file mode 100644
index 0000000000000000000000000000000000000000..50cef9bfe87a2d78d6283beb2ae5b2f310635307
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/bigUintN.js
@@ -0,0 +1,10 @@
+import { BigInt } from '../utils/globals.js';
+import { BigIntArbitrary } from './_internals/BigIntArbitrary.js';
+export function bigUintN(n) {
+ if (n < 0) {
+ throw new Error('fc.bigUintN expects requested number of bits to be superior or equal to 0');
+ }
+ const min = BigInt(0);
+ const max = (BigInt(1) << BigInt(n)) - BigInt(1);
+ return new BigIntArbitrary(min, max);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/boolean.js b/node_modules/fast-check/lib/esm/arbitrary/boolean.js
new file mode 100644
index 0000000000000000000000000000000000000000..ea7581b1c7cea21ea4dd63e3cdbf44bc33e0e50b
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/boolean.js
@@ -0,0 +1,14 @@
+import { integer } from './integer.js';
+import { noBias } from './noBias.js';
+function booleanMapper(v) {
+ return v === 1;
+}
+function booleanUnmapper(v) {
+ if (typeof v !== 'boolean')
+ throw new Error('Unsupported input type');
+ return v === true ? 1 : 0;
+}
+function boolean() {
+ return noBias(integer({ min: 0, max: 1 }).map(booleanMapper, booleanUnmapper));
+}
+export { boolean };
diff --git a/node_modules/fast-check/lib/esm/arbitrary/char.js b/node_modules/fast-check/lib/esm/arbitrary/char.js
new file mode 100644
index 0000000000000000000000000000000000000000..9a0aa73288720692906d0b01eaa8a89bfd4c47ce
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/char.js
@@ -0,0 +1,7 @@
+import { buildCharacterArbitrary } from './_internals/builders/CharacterArbitraryBuilder.js';
+function identity(v) {
+ return v;
+}
+export function char() {
+ return buildCharacterArbitrary(0x20, 0x7e, identity, identity);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/char16bits.js b/node_modules/fast-check/lib/esm/arbitrary/char16bits.js
new file mode 100644
index 0000000000000000000000000000000000000000..0bca533789c46a6a2ee05b9eeb392955bd3bf72d
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/char16bits.js
@@ -0,0 +1,5 @@
+import { buildCharacterArbitrary } from './_internals/builders/CharacterArbitraryBuilder.js';
+import { indexToPrintableIndexMapper, indexToPrintableIndexUnmapper } from './_internals/mappers/IndexToPrintableIndex.js';
+export function char16bits() {
+ return buildCharacterArbitrary(0x0000, 0xffff, indexToPrintableIndexMapper, indexToPrintableIndexUnmapper);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/clone.js b/node_modules/fast-check/lib/esm/arbitrary/clone.js
new file mode 100644
index 0000000000000000000000000000000000000000..a93d092e0e77fc200c7e9f9a974657a582024b69
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/clone.js
@@ -0,0 +1,5 @@
+import { CloneArbitrary } from './_internals/CloneArbitrary.js';
+function clone(arb, numValues) {
+ return new CloneArbitrary(arb, numValues);
+}
+export { clone };
diff --git a/node_modules/fast-check/lib/esm/arbitrary/commands.js b/node_modules/fast-check/lib/esm/arbitrary/commands.js
new file mode 100644
index 0000000000000000000000000000000000000000..60a353721feb80acc37f5bd25e32eb23c591d651
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/commands.js
@@ -0,0 +1,9 @@
+import { CommandsArbitrary } from './_internals/CommandsArbitrary.js';
+import { maxGeneratedLengthFromSizeForArbitrary, MaxLengthUpperBound, } from './_internals/helpers/MaxLengthFromMinLength.js';
+function commands(commandArbs, constraints = {}) {
+ const { size, maxCommands = MaxLengthUpperBound, disableReplayLog = false, replayPath = null } = constraints;
+ const specifiedMaxCommands = constraints.maxCommands !== undefined;
+ const maxGeneratedCommands = maxGeneratedLengthFromSizeForArbitrary(size, 0, maxCommands, specifiedMaxCommands);
+ return new CommandsArbitrary(commandArbs, maxGeneratedCommands, maxCommands, replayPath, disableReplayLog);
+}
+export { commands };
diff --git a/node_modules/fast-check/lib/esm/arbitrary/compareBooleanFunc.js b/node_modules/fast-check/lib/esm/arbitrary/compareBooleanFunc.js
new file mode 100644
index 0000000000000000000000000000000000000000..d04dc766ec0e735e32f4f9917c14cd5d3148b937
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/compareBooleanFunc.js
@@ -0,0 +1,9 @@
+import { buildCompareFunctionArbitrary } from './_internals/builders/CompareFunctionArbitraryBuilder.js';
+const safeObjectAssign = Object.assign;
+export function compareBooleanFunc() {
+ return buildCompareFunctionArbitrary(safeObjectAssign((hA, hB) => hA < hB, {
+ toString() {
+ return '(hA, hB) => hA < hB';
+ },
+ }));
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/compareFunc.js b/node_modules/fast-check/lib/esm/arbitrary/compareFunc.js
new file mode 100644
index 0000000000000000000000000000000000000000..961dada1f637c93289919bac317ec638257292d3
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/compareFunc.js
@@ -0,0 +1,9 @@
+import { buildCompareFunctionArbitrary } from './_internals/builders/CompareFunctionArbitraryBuilder.js';
+const safeObjectAssign = Object.assign;
+export function compareFunc() {
+ return buildCompareFunctionArbitrary(safeObjectAssign((hA, hB) => hA - hB, {
+ toString() {
+ return '(hA, hB) => hA - hB';
+ },
+ }));
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/constant.js b/node_modules/fast-check/lib/esm/arbitrary/constant.js
new file mode 100644
index 0000000000000000000000000000000000000000..6be5c036122433a0684435e217479c2d460c1c43
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/constant.js
@@ -0,0 +1,4 @@
+import { ConstantArbitrary } from './_internals/ConstantArbitrary.js';
+export function constant(value) {
+ return new ConstantArbitrary([value]);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/constantFrom.js b/node_modules/fast-check/lib/esm/arbitrary/constantFrom.js
new file mode 100644
index 0000000000000000000000000000000000000000..749278ff935f7259e2dc3799afdfd9394754232d
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/constantFrom.js
@@ -0,0 +1,8 @@
+import { ConstantArbitrary } from './_internals/ConstantArbitrary.js';
+function constantFrom(...values) {
+ if (values.length === 0) {
+ throw new Error('fc.constantFrom expects at least one parameter');
+ }
+ return new ConstantArbitrary(values);
+}
+export { constantFrom };
diff --git a/node_modules/fast-check/lib/esm/arbitrary/context.js b/node_modules/fast-check/lib/esm/arbitrary/context.js
new file mode 100644
index 0000000000000000000000000000000000000000..f4d79aa7b9738aee13fb739250b9c0998567c90d
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/context.js
@@ -0,0 +1,22 @@
+import { cloneMethod } from '../check/symbols.js';
+import { constant } from './constant.js';
+class ContextImplem {
+ constructor() {
+ this.receivedLogs = [];
+ }
+ log(data) {
+ this.receivedLogs.push(data);
+ }
+ size() {
+ return this.receivedLogs.length;
+ }
+ toString() {
+ return JSON.stringify({ logs: this.receivedLogs });
+ }
+ [cloneMethod]() {
+ return new ContextImplem();
+ }
+}
+export function context() {
+ return constant(new ContextImplem());
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/date.js b/node_modules/fast-check/lib/esm/arbitrary/date.js
new file mode 100644
index 0000000000000000000000000000000000000000..bfb6c7af6ab5777b04cb69ea08c3b3ab36ac182a
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/date.js
@@ -0,0 +1,20 @@
+import { safeGetTime } from '../utils/globals.js';
+import { integer } from './integer.js';
+import { timeToDateMapper, timeToDateMapperWithNaN, timeToDateUnmapper, timeToDateUnmapperWithNaN, } from './_internals/mappers/TimeToDate.js';
+const safeNumberIsNaN = Number.isNaN;
+export function date(constraints = {}) {
+ const intMin = constraints.min !== undefined ? safeGetTime(constraints.min) : -8640000000000000;
+ const intMax = constraints.max !== undefined ? safeGetTime(constraints.max) : 8640000000000000;
+ const noInvalidDate = constraints.noInvalidDate === undefined || constraints.noInvalidDate;
+ if (safeNumberIsNaN(intMin))
+ throw new Error('fc.date min must be valid instance of Date');
+ if (safeNumberIsNaN(intMax))
+ throw new Error('fc.date max must be valid instance of Date');
+ if (intMin > intMax)
+ throw new Error('fc.date max must be greater or equal to min');
+ if (noInvalidDate) {
+ return integer({ min: intMin, max: intMax }).map(timeToDateMapper, timeToDateUnmapper);
+ }
+ const valueForNaN = intMax + 1;
+ return integer({ min: intMin, max: intMax + 1 }).map(timeToDateMapperWithNaN(valueForNaN), timeToDateUnmapperWithNaN(valueForNaN));
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/dictionary.js b/node_modules/fast-check/lib/esm/arbitrary/dictionary.js
new file mode 100644
index 0000000000000000000000000000000000000000..31cfc11cc558dea2e91eaf12e6a38a7b614f8199
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/dictionary.js
@@ -0,0 +1,18 @@
+import { tuple } from './tuple.js';
+import { uniqueArray } from './uniqueArray.js';
+import { keyValuePairsToObjectMapper, keyValuePairsToObjectUnmapper } from './_internals/mappers/KeyValuePairsToObject.js';
+import { constant } from './constant.js';
+import { boolean } from './boolean.js';
+function dictionaryKeyExtractor(entry) {
+ return entry[0];
+}
+export function dictionary(keyArb, valueArb, constraints = {}) {
+ const noNullPrototype = constraints.noNullPrototype !== false;
+ return tuple(uniqueArray(tuple(keyArb, valueArb), {
+ minLength: constraints.minKeys,
+ maxLength: constraints.maxKeys,
+ size: constraints.size,
+ selector: dictionaryKeyExtractor,
+ depthIdentifier: constraints.depthIdentifier,
+ }), noNullPrototype ? constant(false) : boolean()).map(keyValuePairsToObjectMapper, keyValuePairsToObjectUnmapper);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/domain.js b/node_modules/fast-check/lib/esm/arbitrary/domain.js
new file mode 100644
index 0000000000000000000000000000000000000000..03e8ceeba9377f002c76d0e167cbaf012b703a94
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/domain.js
@@ -0,0 +1,56 @@
+import { array } from './array.js';
+import { getOrCreateLowerAlphaArbitrary, getOrCreateLowerAlphaNumericArbitrary, } from './_internals/builders/CharacterRangeArbitraryBuilder.js';
+import { option } from './option.js';
+import { string } from './string.js';
+import { tuple } from './tuple.js';
+import { filterInvalidSubdomainLabel } from './_internals/helpers/InvalidSubdomainLabelFiIter.js';
+import { resolveSize, relativeSizeToSize } from './_internals/helpers/MaxLengthFromMinLength.js';
+import { adapter } from './_internals/AdapterArbitrary.js';
+import { safeJoin, safeSlice, safeSplit, safeSubstring } from '../utils/globals.js';
+function toSubdomainLabelMapper([f, d]) {
+ return d === null ? f : `${f}${d[0]}${d[1]}`;
+}
+function toSubdomainLabelUnmapper(value) {
+ if (typeof value !== 'string' || value.length === 0) {
+ throw new Error('Unsupported');
+ }
+ if (value.length === 1) {
+ return [value[0], null];
+ }
+ return [value[0], [safeSubstring(value, 1, value.length - 1), value[value.length - 1]]];
+}
+function subdomainLabel(size) {
+ const alphaNumericArb = getOrCreateLowerAlphaNumericArbitrary('');
+ const alphaNumericHyphenArb = getOrCreateLowerAlphaNumericArbitrary('-');
+ return tuple(alphaNumericArb, option(tuple(string({ unit: alphaNumericHyphenArb, size, maxLength: 61 }), alphaNumericArb)))
+ .map(toSubdomainLabelMapper, toSubdomainLabelUnmapper)
+ .filter(filterInvalidSubdomainLabel);
+}
+function labelsMapper(elements) {
+ return `${safeJoin(elements[0], '.')}.${elements[1]}`;
+}
+function labelsUnmapper(value) {
+ if (typeof value !== 'string') {
+ throw new Error('Unsupported type');
+ }
+ const lastDotIndex = value.lastIndexOf('.');
+ return [safeSplit(safeSubstring(value, 0, lastDotIndex), '.'), safeSubstring(value, lastDotIndex + 1)];
+}
+function labelsAdapter(labels) {
+ const [subDomains, suffix] = labels;
+ let lengthNotIncludingIndex = suffix.length;
+ for (let index = 0; index !== subDomains.length; ++index) {
+ lengthNotIncludingIndex += 1 + subDomains[index].length;
+ if (lengthNotIncludingIndex > 255) {
+ return { adapted: true, value: [safeSlice(subDomains, 0, index), suffix] };
+ }
+ }
+ return { adapted: false, value: labels };
+}
+export function domain(constraints = {}) {
+ const resolvedSize = resolveSize(constraints.size);
+ const resolvedSizeMinusOne = relativeSizeToSize('-1', resolvedSize);
+ const lowerAlphaArb = getOrCreateLowerAlphaArbitrary();
+ const publicSuffixArb = string({ unit: lowerAlphaArb, minLength: 2, maxLength: 63, size: resolvedSizeMinusOne });
+ return (adapter(tuple(array(subdomainLabel(resolvedSize), { size: resolvedSizeMinusOne, minLength: 1, maxLength: 127 }), publicSuffixArb), labelsAdapter).map(labelsMapper, labelsUnmapper));
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/double.js b/node_modules/fast-check/lib/esm/arbitrary/double.js
new file mode 100644
index 0000000000000000000000000000000000000000..69a1900f62e9bcbcf3cf9f7c09aec778062e0231
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/double.js
@@ -0,0 +1,60 @@
+import { add64, isEqual64, isStrictlyPositive64, isStrictlySmaller64, substract64, Unit64, } from './_internals/helpers/ArrayInt64.js';
+import { arrayInt64 } from './_internals/ArrayInt64Arbitrary.js';
+import { doubleToIndex, indexToDouble } from './_internals/helpers/DoubleHelpers.js';
+import { doubleOnlyMapper, doubleOnlyUnmapper, refineConstraintsForDoubleOnly, } from './_internals/helpers/DoubleOnlyHelpers.js';
+const safeNumberIsInteger = Number.isInteger;
+const safeNumberIsNaN = Number.isNaN;
+const safeNegativeInfinity = Number.NEGATIVE_INFINITY;
+const safePositiveInfinity = Number.POSITIVE_INFINITY;
+const safeMaxValue = Number.MAX_VALUE;
+const safeNaN = Number.NaN;
+function safeDoubleToIndex(d, constraintsLabel) {
+ if (safeNumberIsNaN(d)) {
+ throw new Error('fc.double constraints.' + constraintsLabel + ' must be a 64-bit float');
+ }
+ return doubleToIndex(d);
+}
+function unmapperDoubleToIndex(value) {
+ if (typeof value !== 'number')
+ throw new Error('Unsupported type');
+ return doubleToIndex(value);
+}
+function numberIsNotInteger(value) {
+ return !safeNumberIsInteger(value);
+}
+function anyDouble(constraints) {
+ const { noDefaultInfinity = false, noNaN = false, minExcluded = false, maxExcluded = false, min = noDefaultInfinity ? -safeMaxValue : safeNegativeInfinity, max = noDefaultInfinity ? safeMaxValue : safePositiveInfinity, } = constraints;
+ const minIndexRaw = safeDoubleToIndex(min, 'min');
+ const minIndex = minExcluded ? add64(minIndexRaw, Unit64) : minIndexRaw;
+ const maxIndexRaw = safeDoubleToIndex(max, 'max');
+ const maxIndex = maxExcluded ? substract64(maxIndexRaw, Unit64) : maxIndexRaw;
+ if (isStrictlySmaller64(maxIndex, minIndex)) {
+ throw new Error('fc.double constraints.min must be smaller or equal to constraints.max');
+ }
+ if (noNaN) {
+ return arrayInt64(minIndex, maxIndex).map(indexToDouble, unmapperDoubleToIndex);
+ }
+ const positiveMaxIdx = isStrictlyPositive64(maxIndex);
+ const minIndexWithNaN = positiveMaxIdx ? minIndex : substract64(minIndex, Unit64);
+ const maxIndexWithNaN = positiveMaxIdx ? add64(maxIndex, Unit64) : maxIndex;
+ return arrayInt64(minIndexWithNaN, maxIndexWithNaN).map((index) => {
+ if (isStrictlySmaller64(maxIndex, index) || isStrictlySmaller64(index, minIndex))
+ return safeNaN;
+ else
+ return indexToDouble(index);
+ }, (value) => {
+ if (typeof value !== 'number')
+ throw new Error('Unsupported type');
+ if (safeNumberIsNaN(value))
+ return !isEqual64(maxIndex, maxIndexWithNaN) ? maxIndexWithNaN : minIndexWithNaN;
+ return doubleToIndex(value);
+ });
+}
+export function double(constraints = {}) {
+ if (!constraints.noInteger) {
+ return anyDouble(constraints);
+ }
+ return anyDouble(refineConstraintsForDoubleOnly(constraints))
+ .map(doubleOnlyMapper, doubleOnlyUnmapper)
+ .filter(numberIsNotInteger);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/emailAddress.js b/node_modules/fast-check/lib/esm/arbitrary/emailAddress.js
new file mode 100644
index 0000000000000000000000000000000000000000..0e4b854dc6e1c0e78b3ca452f883fd51f2bd0eaf
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/emailAddress.js
@@ -0,0 +1,45 @@
+import { array } from './array.js';
+import { getOrCreateLowerAlphaNumericArbitrary } from './_internals/builders/CharacterRangeArbitraryBuilder.js';
+import { domain } from './domain.js';
+import { string } from './string.js';
+import { tuple } from './tuple.js';
+import { adapter } from './_internals/AdapterArbitrary.js';
+import { safeJoin, safeSlice, safeSplit } from '../utils/globals.js';
+function dotAdapter(a) {
+ let currentLength = a[0].length;
+ for (let index = 1; index !== a.length; ++index) {
+ currentLength += 1 + a[index].length;
+ if (currentLength > 64) {
+ return { adapted: true, value: safeSlice(a, 0, index) };
+ }
+ }
+ return { adapted: false, value: a };
+}
+function dotMapper(a) {
+ return safeJoin(a, '.');
+}
+function dotUnmapper(value) {
+ if (typeof value !== 'string') {
+ throw new Error('Unsupported');
+ }
+ return safeSplit(value, '.');
+}
+function atMapper(data) {
+ return `${data[0]}@${data[1]}`;
+}
+function atUnmapper(value) {
+ if (typeof value !== 'string') {
+ throw new Error('Unsupported');
+ }
+ return safeSplit(value, '@', 2);
+}
+export function emailAddress(constraints = {}) {
+ const atextArb = getOrCreateLowerAlphaNumericArbitrary("!#$%&'*+-/=?^_`{|}~");
+ const localPartArb = adapter(array(string({
+ unit: atextArb,
+ minLength: 1,
+ maxLength: 64,
+ size: constraints.size,
+ }), { minLength: 1, maxLength: 32, size: constraints.size }), dotAdapter).map(dotMapper, dotUnmapper);
+ return tuple(localPartArb, domain({ size: constraints.size })).map(atMapper, atUnmapper);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/falsy.js b/node_modules/fast-check/lib/esm/arbitrary/falsy.js
new file mode 100644
index 0000000000000000000000000000000000000000..518d36156d928fb25f395e9f348edec2de2c2212
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/falsy.js
@@ -0,0 +1,8 @@
+import { BigInt } from '../utils/globals.js';
+import { constantFrom } from './constantFrom.js';
+export function falsy(constraints) {
+ if (!constraints || !constraints.withBigInt) {
+ return constantFrom(false, null, undefined, 0, '', NaN);
+ }
+ return constantFrom(false, null, undefined, 0, '', NaN, BigInt(0));
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/float.js b/node_modules/fast-check/lib/esm/arbitrary/float.js
new file mode 100644
index 0000000000000000000000000000000000000000..f345d22f232da08ed41c6a121479112764ae45b2
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/float.js
@@ -0,0 +1,60 @@
+import { integer } from './integer.js';
+import { floatToIndex, indexToFloat, MAX_VALUE_32 } from './_internals/helpers/FloatHelpers.js';
+import { floatOnlyMapper, floatOnlyUnmapper, refineConstraintsForFloatOnly, } from './_internals/helpers/FloatOnlyHelpers.js';
+const safeNumberIsInteger = Number.isInteger;
+const safeNumberIsNaN = Number.isNaN;
+const safeMathFround = Math.fround;
+const safeNegativeInfinity = Number.NEGATIVE_INFINITY;
+const safePositiveInfinity = Number.POSITIVE_INFINITY;
+const safeNaN = Number.NaN;
+function safeFloatToIndex(f, constraintsLabel) {
+ const conversionTrick = 'you can convert any double to a 32-bit float by using `Math.fround(myDouble)`';
+ const errorMessage = 'fc.float constraints.' + constraintsLabel + ' must be a 32-bit float - ' + conversionTrick;
+ if (safeNumberIsNaN(f) || safeMathFround(f) !== f) {
+ throw new Error(errorMessage);
+ }
+ return floatToIndex(f);
+}
+function unmapperFloatToIndex(value) {
+ if (typeof value !== 'number')
+ throw new Error('Unsupported type');
+ return floatToIndex(value);
+}
+function numberIsNotInteger(value) {
+ return !safeNumberIsInteger(value);
+}
+function anyFloat(constraints) {
+ const { noDefaultInfinity = false, noNaN = false, minExcluded = false, maxExcluded = false, min = noDefaultInfinity ? -MAX_VALUE_32 : safeNegativeInfinity, max = noDefaultInfinity ? MAX_VALUE_32 : safePositiveInfinity, } = constraints;
+ const minIndexRaw = safeFloatToIndex(min, 'min');
+ const minIndex = minExcluded ? minIndexRaw + 1 : minIndexRaw;
+ const maxIndexRaw = safeFloatToIndex(max, 'max');
+ const maxIndex = maxExcluded ? maxIndexRaw - 1 : maxIndexRaw;
+ if (minIndex > maxIndex) {
+ throw new Error('fc.float constraints.min must be smaller or equal to constraints.max');
+ }
+ if (noNaN) {
+ return integer({ min: minIndex, max: maxIndex }).map(indexToFloat, unmapperFloatToIndex);
+ }
+ const minIndexWithNaN = maxIndex > 0 ? minIndex : minIndex - 1;
+ const maxIndexWithNaN = maxIndex > 0 ? maxIndex + 1 : maxIndex;
+ return integer({ min: minIndexWithNaN, max: maxIndexWithNaN }).map((index) => {
+ if (index > maxIndex || index < minIndex)
+ return safeNaN;
+ else
+ return indexToFloat(index);
+ }, (value) => {
+ if (typeof value !== 'number')
+ throw new Error('Unsupported type');
+ if (safeNumberIsNaN(value))
+ return maxIndex !== maxIndexWithNaN ? maxIndexWithNaN : minIndexWithNaN;
+ return floatToIndex(value);
+ });
+}
+export function float(constraints = {}) {
+ if (!constraints.noInteger) {
+ return anyFloat(constraints);
+ }
+ return anyFloat(refineConstraintsForFloatOnly(constraints))
+ .map(floatOnlyMapper, floatOnlyUnmapper)
+ .filter(numberIsNotInteger);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/float32Array.js b/node_modules/fast-check/lib/esm/arbitrary/float32Array.js
new file mode 100644
index 0000000000000000000000000000000000000000..be1792d409dcdfe975e624c62ac68a88f89a6408
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/float32Array.js
@@ -0,0 +1,14 @@
+import { float } from './float.js';
+import { array } from './array.js';
+import { Float32Array } from '../utils/globals.js';
+function toTypedMapper(data) {
+ return Float32Array.from(data);
+}
+function fromTypedUnmapper(value) {
+ if (!(value instanceof Float32Array))
+ throw new Error('Unexpected type');
+ return [...value];
+}
+export function float32Array(constraints = {}) {
+ return array(float(constraints), constraints).map(toTypedMapper, fromTypedUnmapper);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/float64Array.js b/node_modules/fast-check/lib/esm/arbitrary/float64Array.js
new file mode 100644
index 0000000000000000000000000000000000000000..b495007e10347cc7341ca854a786c85f18835f2d
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/float64Array.js
@@ -0,0 +1,14 @@
+import { double } from './double.js';
+import { array } from './array.js';
+import { Float64Array } from '../utils/globals.js';
+function toTypedMapper(data) {
+ return Float64Array.from(data);
+}
+function fromTypedUnmapper(value) {
+ if (!(value instanceof Float64Array))
+ throw new Error('Unexpected type');
+ return [...value];
+}
+export function float64Array(constraints = {}) {
+ return array(double(constraints), constraints).map(toTypedMapper, fromTypedUnmapper);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/fullUnicode.js b/node_modules/fast-check/lib/esm/arbitrary/fullUnicode.js
new file mode 100644
index 0000000000000000000000000000000000000000..9c6159f47738aef369e33e557a53e764b2f41679
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/fullUnicode.js
@@ -0,0 +1,18 @@
+import { buildCharacterArbitrary } from './_internals/builders/CharacterArbitraryBuilder.js';
+import { indexToPrintableIndexMapper, indexToPrintableIndexUnmapper } from './_internals/mappers/IndexToPrintableIndex.js';
+const gapSize = 0xdfff + 1 - 0xd800;
+function unicodeMapper(v) {
+ if (v < 0xd800)
+ return indexToPrintableIndexMapper(v);
+ return v + gapSize;
+}
+function unicodeUnmapper(v) {
+ if (v < 0xd800)
+ return indexToPrintableIndexUnmapper(v);
+ if (v <= 0xdfff)
+ return -1;
+ return v - gapSize;
+}
+export function fullUnicode() {
+ return buildCharacterArbitrary(0x0000, 0x10ffff - gapSize, unicodeMapper, unicodeUnmapper);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/fullUnicodeString.js b/node_modules/fast-check/lib/esm/arbitrary/fullUnicodeString.js
new file mode 100644
index 0000000000000000000000000000000000000000..67f863970e30336642c7949b3f7fa3facd4ba5e6
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/fullUnicodeString.js
@@ -0,0 +1,13 @@
+import { array } from './array.js';
+import { fullUnicode } from './fullUnicode.js';
+import { codePointsToStringMapper, codePointsToStringUnmapper } from './_internals/mappers/CodePointsToString.js';
+import { createSlicesForStringLegacy } from './_internals/helpers/SlicesForStringBuilder.js';
+const safeObjectAssign = Object.assign;
+export function fullUnicodeString(constraints = {}) {
+ const charArbitrary = fullUnicode();
+ const experimentalCustomSlices = createSlicesForStringLegacy(charArbitrary, codePointsToStringUnmapper);
+ const enrichedConstraints = safeObjectAssign(safeObjectAssign({}, constraints), {
+ experimentalCustomSlices,
+ });
+ return array(charArbitrary, enrichedConstraints).map(codePointsToStringMapper, codePointsToStringUnmapper);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/func.js b/node_modules/fast-check/lib/esm/arbitrary/func.js
new file mode 100644
index 0000000000000000000000000000000000000000..2f9baf330a95f7da748f366e099781ff1771e23b
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/func.js
@@ -0,0 +1,39 @@
+import { hash } from '../utils/hash.js';
+import { asyncStringify, asyncToStringMethod, stringify, toStringMethod } from '../utils/stringify.js';
+import { cloneMethod, hasCloneMethod } from '../check/symbols.js';
+import { array } from './array.js';
+import { integer } from './integer.js';
+import { noShrink } from './noShrink.js';
+import { tuple } from './tuple.js';
+import { escapeForMultilineComments } from './_internals/helpers/TextEscaper.js';
+import { safeMap, safeSort } from '../utils/globals.js';
+const safeObjectDefineProperties = Object.defineProperties;
+const safeObjectKeys = Object.keys;
+export function func(arb) {
+ return tuple(array(arb, { minLength: 1 }), noShrink(integer())).map(([outs, seed]) => {
+ const producer = () => {
+ const recorded = {};
+ const f = (...args) => {
+ const repr = stringify(args);
+ const val = outs[hash(`${seed}${repr}`) % outs.length];
+ recorded[repr] = val;
+ return hasCloneMethod(val) ? val[cloneMethod]() : val;
+ };
+ function prettyPrint(stringifiedOuts) {
+ const seenValues = safeMap(safeMap(safeSort(safeObjectKeys(recorded)), (k) => `${k} => ${stringify(recorded[k])}`), (line) => `/* ${escapeForMultilineComments(line)} */`);
+ return `function(...args) {
+ // With hash and stringify coming from fast-check${seenValues.length !== 0 ? `\n ${seenValues.join('\n ')}` : ''}
+ const outs = ${stringifiedOuts};
+ return outs[hash('${seed}' + stringify(args)) % outs.length];
+}`;
+ }
+ return safeObjectDefineProperties(f, {
+ toString: { value: () => prettyPrint(stringify(outs)) },
+ [toStringMethod]: { value: () => prettyPrint(stringify(outs)) },
+ [asyncToStringMethod]: { value: async () => prettyPrint(await asyncStringify(outs)) },
+ [cloneMethod]: { value: producer, configurable: true },
+ });
+ };
+ return producer();
+ });
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/gen.js b/node_modules/fast-check/lib/esm/arbitrary/gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..39de8471ce8e29c32337fe57b46cb605397bc60f
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/gen.js
@@ -0,0 +1,4 @@
+import { GeneratorArbitrary } from './_internals/GeneratorArbitrary.js';
+export function gen() {
+ return new GeneratorArbitrary();
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/hexa.js b/node_modules/fast-check/lib/esm/arbitrary/hexa.js
new file mode 100644
index 0000000000000000000000000000000000000000..078b53b809423d6bc1304580236a1835f0fccb01
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/hexa.js
@@ -0,0 +1,16 @@
+import { buildCharacterArbitrary } from './_internals/builders/CharacterArbitraryBuilder.js';
+function hexaMapper(v) {
+ return v < 10
+ ? v + 48
+ : v + 97 - 10;
+}
+function hexaUnmapper(v) {
+ return v < 58
+ ? v - 48
+ : v >= 97 && v < 103
+ ? v - 97 + 10
+ : -1;
+}
+export function hexa() {
+ return buildCharacterArbitrary(0, 15, hexaMapper, hexaUnmapper);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/hexaString.js b/node_modules/fast-check/lib/esm/arbitrary/hexaString.js
new file mode 100644
index 0000000000000000000000000000000000000000..8b18a1850e925d5a187e156b214da39e6787cf21
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/hexaString.js
@@ -0,0 +1,14 @@
+import { array } from './array.js';
+import { hexa } from './hexa.js';
+import { codePointsToStringMapper, codePointsToStringUnmapper } from './_internals/mappers/CodePointsToString.js';
+import { createSlicesForStringLegacy } from './_internals/helpers/SlicesForStringBuilder.js';
+const safeObjectAssign = Object.assign;
+function hexaString(constraints = {}) {
+ const charArbitrary = hexa();
+ const experimentalCustomSlices = createSlicesForStringLegacy(charArbitrary, codePointsToStringUnmapper);
+ const enrichedConstraints = safeObjectAssign(safeObjectAssign({}, constraints), {
+ experimentalCustomSlices,
+ });
+ return array(charArbitrary, enrichedConstraints).map(codePointsToStringMapper, codePointsToStringUnmapper);
+}
+export { hexaString };
diff --git a/node_modules/fast-check/lib/esm/arbitrary/infiniteStream.js b/node_modules/fast-check/lib/esm/arbitrary/infiniteStream.js
new file mode 100644
index 0000000000000000000000000000000000000000..21d4fe6b4f95c5b03b31377c321367ae9ec6996e
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/infiniteStream.js
@@ -0,0 +1,5 @@
+import { StreamArbitrary } from './_internals/StreamArbitrary.js';
+function infiniteStream(arb) {
+ return new StreamArbitrary(arb);
+}
+export { infiniteStream };
diff --git a/node_modules/fast-check/lib/esm/arbitrary/int16Array.js b/node_modules/fast-check/lib/esm/arbitrary/int16Array.js
new file mode 100644
index 0000000000000000000000000000000000000000..37bef311afd2357d2af23b0c7c615b0e28bb184a
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/int16Array.js
@@ -0,0 +1,6 @@
+import { Int16Array } from '../utils/globals.js';
+import { integer } from './integer.js';
+import { typedIntArrayArbitraryArbitraryBuilder } from './_internals/builders/TypedIntArrayArbitraryBuilder.js';
+export function int16Array(constraints = {}) {
+ return typedIntArrayArbitraryArbitraryBuilder(constraints, -32768, 32767, Int16Array, integer);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/int32Array.js b/node_modules/fast-check/lib/esm/arbitrary/int32Array.js
new file mode 100644
index 0000000000000000000000000000000000000000..c784e19cb7ddff5d8f67ad3728a52024e8e329d4
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/int32Array.js
@@ -0,0 +1,6 @@
+import { Int32Array } from '../utils/globals.js';
+import { integer } from './integer.js';
+import { typedIntArrayArbitraryArbitraryBuilder } from './_internals/builders/TypedIntArrayArbitraryBuilder.js';
+export function int32Array(constraints = {}) {
+ return typedIntArrayArbitraryArbitraryBuilder(constraints, -0x80000000, 0x7fffffff, Int32Array, integer);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/int8Array.js b/node_modules/fast-check/lib/esm/arbitrary/int8Array.js
new file mode 100644
index 0000000000000000000000000000000000000000..6d4d8e2f03c9b1b9c3daa92fd66f4526fb01fdbf
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/int8Array.js
@@ -0,0 +1,6 @@
+import { Int8Array } from '../utils/globals.js';
+import { integer } from './integer.js';
+import { typedIntArrayArbitraryArbitraryBuilder } from './_internals/builders/TypedIntArrayArbitraryBuilder.js';
+export function int8Array(constraints = {}) {
+ return typedIntArrayArbitraryArbitraryBuilder(constraints, -128, 127, Int8Array, integer);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/integer.js b/node_modules/fast-check/lib/esm/arbitrary/integer.js
new file mode 100644
index 0000000000000000000000000000000000000000..745c2127dd320b31fb873f9fa6c778ae0a460373
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/integer.js
@@ -0,0 +1,20 @@
+import { IntegerArbitrary } from './_internals/IntegerArbitrary.js';
+const safeNumberIsInteger = Number.isInteger;
+function buildCompleteIntegerConstraints(constraints) {
+ const min = constraints.min !== undefined ? constraints.min : -0x80000000;
+ const max = constraints.max !== undefined ? constraints.max : 0x7fffffff;
+ return { min, max };
+}
+export function integer(constraints = {}) {
+ const fullConstraints = buildCompleteIntegerConstraints(constraints);
+ if (fullConstraints.min > fullConstraints.max) {
+ throw new Error('fc.integer maximum value should be equal or greater than the minimum one');
+ }
+ if (!safeNumberIsInteger(fullConstraints.min)) {
+ throw new Error('fc.integer minimum value should be an integer');
+ }
+ if (!safeNumberIsInteger(fullConstraints.max)) {
+ throw new Error('fc.integer maximum value should be an integer');
+ }
+ return new IntegerArbitrary(fullConstraints.min, fullConstraints.max);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/ipV4.js b/node_modules/fast-check/lib/esm/arbitrary/ipV4.js
new file mode 100644
index 0000000000000000000000000000000000000000..e71c688c9808aa7ea93552e0a8d0563628ca1543
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/ipV4.js
@@ -0,0 +1,16 @@
+import { safeJoin, safeMap, safeSplit } from '../utils/globals.js';
+import { nat } from './nat.js';
+import { tuple } from './tuple.js';
+import { tryParseStringifiedNat } from './_internals/mappers/NatToStringifiedNat.js';
+function dotJoinerMapper(data) {
+ return safeJoin(data, '.');
+}
+function dotJoinerUnmapper(value) {
+ if (typeof value !== 'string') {
+ throw new Error('Invalid type');
+ }
+ return safeMap(safeSplit(value, '.'), (v) => tryParseStringifiedNat(v, 10));
+}
+export function ipV4() {
+ return tuple(nat(255), nat(255), nat(255), nat(255)).map(dotJoinerMapper, dotJoinerUnmapper);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/ipV4Extended.js b/node_modules/fast-check/lib/esm/arbitrary/ipV4Extended.js
new file mode 100644
index 0000000000000000000000000000000000000000..cf639dbb7009829b317a567d324935761d5f8c18
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/ipV4Extended.js
@@ -0,0 +1,16 @@
+import { safeJoin, safeSplit } from '../utils/globals.js';
+import { oneof } from './oneof.js';
+import { tuple } from './tuple.js';
+import { buildStringifiedNatArbitrary } from './_internals/builders/StringifiedNatArbitraryBuilder.js';
+function dotJoinerMapper(data) {
+ return safeJoin(data, '.');
+}
+function dotJoinerUnmapper(value) {
+ if (typeof value !== 'string') {
+ throw new Error('Invalid type');
+ }
+ return safeSplit(value, '.');
+}
+export function ipV4Extended() {
+ return oneof(tuple(buildStringifiedNatArbitrary(255), buildStringifiedNatArbitrary(255), buildStringifiedNatArbitrary(255), buildStringifiedNatArbitrary(255)).map(dotJoinerMapper, dotJoinerUnmapper), tuple(buildStringifiedNatArbitrary(255), buildStringifiedNatArbitrary(255), buildStringifiedNatArbitrary(65535)).map(dotJoinerMapper, dotJoinerUnmapper), tuple(buildStringifiedNatArbitrary(255), buildStringifiedNatArbitrary(16777215)).map(dotJoinerMapper, dotJoinerUnmapper), buildStringifiedNatArbitrary(4294967295));
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/ipV6.js b/node_modules/fast-check/lib/esm/arbitrary/ipV6.js
new file mode 100644
index 0000000000000000000000000000000000000000..b52002d063106d6c9ea5352971cef80905287169
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/ipV6.js
@@ -0,0 +1,21 @@
+import { array } from './array.js';
+import { oneof } from './oneof.js';
+import { hexaString } from './hexaString.js';
+import { tuple } from './tuple.js';
+import { ipV4 } from './ipV4.js';
+import { fullySpecifiedMapper, fullySpecifiedUnmapper, onlyTrailingMapper, onlyTrailingUnmapper, multiTrailingMapper, multiTrailingUnmapper, multiTrailingMapperOne, multiTrailingUnmapperOne, singleTrailingMapper, singleTrailingUnmapper, noTrailingMapper, noTrailingUnmapper, } from './_internals/mappers/EntitiesToIPv6.js';
+function h16sTol32Mapper([a, b]) {
+ return `${a}:${b}`;
+}
+function h16sTol32Unmapper(value) {
+ if (typeof value !== 'string')
+ throw new Error('Invalid type');
+ if (!value.includes(':'))
+ throw new Error('Invalid value');
+ return value.split(':', 2);
+}
+export function ipV6() {
+ const h16Arb = hexaString({ minLength: 1, maxLength: 4, size: 'max' });
+ const ls32Arb = oneof(tuple(h16Arb, h16Arb).map(h16sTol32Mapper, h16sTol32Unmapper), ipV4());
+ return oneof(tuple(array(h16Arb, { minLength: 6, maxLength: 6, size: 'max' }), ls32Arb).map(fullySpecifiedMapper, fullySpecifiedUnmapper), tuple(array(h16Arb, { minLength: 5, maxLength: 5, size: 'max' }), ls32Arb).map(onlyTrailingMapper, onlyTrailingUnmapper), tuple(array(h16Arb, { minLength: 0, maxLength: 1, size: 'max' }), array(h16Arb, { minLength: 4, maxLength: 4, size: 'max' }), ls32Arb).map(multiTrailingMapper, multiTrailingUnmapper), tuple(array(h16Arb, { minLength: 0, maxLength: 2, size: 'max' }), array(h16Arb, { minLength: 3, maxLength: 3, size: 'max' }), ls32Arb).map(multiTrailingMapper, multiTrailingUnmapper), tuple(array(h16Arb, { minLength: 0, maxLength: 3, size: 'max' }), array(h16Arb, { minLength: 2, maxLength: 2, size: 'max' }), ls32Arb).map(multiTrailingMapper, multiTrailingUnmapper), tuple(array(h16Arb, { minLength: 0, maxLength: 4, size: 'max' }), h16Arb, ls32Arb).map(multiTrailingMapperOne, multiTrailingUnmapperOne), tuple(array(h16Arb, { minLength: 0, maxLength: 5, size: 'max' }), ls32Arb).map(singleTrailingMapper, singleTrailingUnmapper), tuple(array(h16Arb, { minLength: 0, maxLength: 6, size: 'max' }), h16Arb).map(singleTrailingMapper, singleTrailingUnmapper), tuple(array(h16Arb, { minLength: 0, maxLength: 7, size: 'max' })).map(noTrailingMapper, noTrailingUnmapper));
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/json.js b/node_modules/fast-check/lib/esm/arbitrary/json.js
new file mode 100644
index 0000000000000000000000000000000000000000..875c0d519b1023da1e547d43d0410424125e3fde
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/json.js
@@ -0,0 +1,5 @@
+import { jsonValue } from './jsonValue.js';
+export function json(constraints = {}) {
+ const arb = jsonValue(constraints);
+ return arb.map(JSON.stringify);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/jsonValue.js b/node_modules/fast-check/lib/esm/arbitrary/jsonValue.js
new file mode 100644
index 0000000000000000000000000000000000000000..58384808b6a1ecff707f87774405aae3b1516834
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/jsonValue.js
@@ -0,0 +1,13 @@
+import { string } from './string.js';
+import { jsonConstraintsBuilder } from './_internals/helpers/JsonConstraintsBuilder.js';
+import { anything } from './anything.js';
+import { fullUnicodeString } from './fullUnicodeString.js';
+export function jsonValue(constraints = {}) {
+ const noUnicodeString = constraints.noUnicodeString === undefined || constraints.noUnicodeString === true;
+ const stringArbitrary = 'stringUnit' in constraints
+ ? string({ unit: constraints.stringUnit })
+ : noUnicodeString
+ ? string()
+ : fullUnicodeString();
+ return anything(jsonConstraintsBuilder(stringArbitrary, constraints));
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/letrec.js b/node_modules/fast-check/lib/esm/arbitrary/letrec.js
new file mode 100644
index 0000000000000000000000000000000000000000..3a9738f82808349f284601b2cb8b0f2e90e2c87d
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/letrec.js
@@ -0,0 +1,23 @@
+import { LazyArbitrary } from './_internals/LazyArbitrary.js';
+import { safeHasOwnProperty } from '../utils/globals.js';
+const safeObjectCreate = Object.create;
+export function letrec(builder) {
+ const lazyArbs = safeObjectCreate(null);
+ const tie = (key) => {
+ if (!safeHasOwnProperty(lazyArbs, key)) {
+ lazyArbs[key] = new LazyArbitrary(String(key));
+ }
+ return lazyArbs[key];
+ };
+ const strictArbs = builder(tie);
+ for (const key in strictArbs) {
+ if (!safeHasOwnProperty(strictArbs, key)) {
+ continue;
+ }
+ const lazyAtKey = lazyArbs[key];
+ const lazyArb = lazyAtKey !== undefined ? lazyAtKey : new LazyArbitrary(key);
+ lazyArb.underlying = strictArbs[key];
+ lazyArbs[key] = lazyArb;
+ }
+ return strictArbs;
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/limitShrink.js b/node_modules/fast-check/lib/esm/arbitrary/limitShrink.js
new file mode 100644
index 0000000000000000000000000000000000000000..f19cc7ef8b05bb3a2a30743cdfe82f90338306cb
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/limitShrink.js
@@ -0,0 +1,4 @@
+import { LimitedShrinkArbitrary } from './_internals/LimitedShrinkArbitrary.js';
+export function limitShrink(arbitrary, maxShrinks) {
+ return new LimitedShrinkArbitrary(arbitrary, maxShrinks);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/lorem.js b/node_modules/fast-check/lib/esm/arbitrary/lorem.js
new file mode 100644
index 0000000000000000000000000000000000000000..55013c6636d78b1635e6bda4315e572725b606eb
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/lorem.js
@@ -0,0 +1,24 @@
+import { array } from './array.js';
+import { constant } from './constant.js';
+import { oneof } from './oneof.js';
+import { sentencesToParagraphMapper, sentencesToParagraphUnmapper, wordsToJoinedStringMapper, wordsToJoinedStringUnmapperFor, wordsToSentenceMapper, wordsToSentenceUnmapperFor, } from './_internals/mappers/WordsToLorem.js';
+const h = (v, w) => {
+ return { arbitrary: constant(v), weight: w };
+};
+function loremWord() {
+ return oneof(h('non', 6), h('adipiscing', 5), h('ligula', 5), h('enim', 5), h('pellentesque', 5), h('in', 5), h('augue', 5), h('et', 5), h('nulla', 5), h('lorem', 4), h('sit', 4), h('sed', 4), h('diam', 4), h('fermentum', 4), h('ut', 4), h('eu', 4), h('aliquam', 4), h('mauris', 4), h('vitae', 4), h('felis', 4), h('ipsum', 3), h('dolor', 3), h('amet,', 3), h('elit', 3), h('euismod', 3), h('mi', 3), h('orci', 3), h('erat', 3), h('praesent', 3), h('egestas', 3), h('leo', 3), h('vel', 3), h('sapien', 3), h('integer', 3), h('curabitur', 3), h('convallis', 3), h('purus', 3), h('risus', 2), h('suspendisse', 2), h('lectus', 2), h('nec,', 2), h('ultricies', 2), h('sed,', 2), h('cras', 2), h('elementum', 2), h('ultrices', 2), h('maecenas', 2), h('massa,', 2), h('varius', 2), h('a,', 2), h('semper', 2), h('proin', 2), h('nec', 2), h('nisl', 2), h('amet', 2), h('duis', 2), h('congue', 2), h('libero', 2), h('vestibulum', 2), h('pede', 2), h('blandit', 2), h('sodales', 2), h('ante', 2), h('nibh', 2), h('ac', 2), h('aenean', 2), h('massa', 2), h('suscipit', 2), h('sollicitudin', 2), h('fusce', 2), h('tempus', 2), h('aliquam,', 2), h('nunc', 2), h('ullamcorper', 2), h('rhoncus', 2), h('metus', 2), h('faucibus,', 2), h('justo', 2), h('magna', 2), h('at', 2), h('tincidunt', 2), h('consectetur', 1), h('tortor,', 1), h('dignissim', 1), h('congue,', 1), h('non,', 1), h('porttitor,', 1), h('nonummy', 1), h('molestie,', 1), h('est', 1), h('eleifend', 1), h('mi,', 1), h('arcu', 1), h('scelerisque', 1), h('vitae,', 1), h('consequat', 1), h('in,', 1), h('pretium', 1), h('volutpat', 1), h('pharetra', 1), h('tempor', 1), h('bibendum', 1), h('odio', 1), h('dui', 1), h('primis', 1), h('faucibus', 1), h('luctus', 1), h('posuere', 1), h('cubilia', 1), h('curae,', 1), h('hendrerit', 1), h('velit', 1), h('mauris,', 1), h('gravida', 1), h('ornare', 1), h('ut,', 1), h('pulvinar', 1), h('varius,', 1), h('turpis', 1), h('nibh,', 1), h('eros', 1), h('id', 1), h('aliquet', 1), h('quis', 1), h('lobortis', 1), h('consectetuer', 1), h('morbi', 1), h('vehicula', 1), h('tortor', 1), h('tellus,', 1), h('id,', 1), h('eu,', 1), h('quam', 1), h('feugiat,', 1), h('posuere,', 1), h('iaculis', 1), h('lectus,', 1), h('tristique', 1), h('mollis,', 1), h('nisl,', 1), h('vulputate', 1), h('sem', 1), h('vivamus', 1), h('placerat', 1), h('imperdiet', 1), h('cursus', 1), h('rutrum', 1), h('iaculis,', 1), h('augue,', 1), h('lacus', 1));
+}
+export function lorem(constraints = {}) {
+ const { maxCount, mode = 'words', size } = constraints;
+ if (maxCount !== undefined && maxCount < 1) {
+ throw new Error(`lorem has to produce at least one word/sentence`);
+ }
+ const wordArbitrary = loremWord();
+ if (mode === 'sentences') {
+ const sentence = array(wordArbitrary, { minLength: 1, size: 'small' }).map(wordsToSentenceMapper, wordsToSentenceUnmapperFor(wordArbitrary));
+ return array(sentence, { minLength: 1, maxLength: maxCount, size }).map(sentencesToParagraphMapper, sentencesToParagraphUnmapper);
+ }
+ else {
+ return array(wordArbitrary, { minLength: 1, maxLength: maxCount, size }).map(wordsToJoinedStringMapper, wordsToJoinedStringUnmapperFor(wordArbitrary));
+ }
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/mapToConstant.js b/node_modules/fast-check/lib/esm/arbitrary/mapToConstant.js
new file mode 100644
index 0000000000000000000000000000000000000000..81c59037536e93c1aea714c6acbd1b1eb9dc69b9
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/mapToConstant.js
@@ -0,0 +1,20 @@
+import { nat } from './nat.js';
+import { indexToMappedConstantMapperFor, indexToMappedConstantUnmapperFor, } from './_internals/mappers/IndexToMappedConstant.js';
+import { Error } from '../utils/globals.js';
+function computeNumChoices(options) {
+ if (options.length === 0)
+ throw new Error(`fc.mapToConstant expects at least one option`);
+ let numChoices = 0;
+ for (let idx = 0; idx !== options.length; ++idx) {
+ if (options[idx].num < 0)
+ throw new Error(`fc.mapToConstant expects all options to have a number of entries greater or equal to zero`);
+ numChoices += options[idx].num;
+ }
+ if (numChoices === 0)
+ throw new Error(`fc.mapToConstant expects at least one choice among options`);
+ return numChoices;
+}
+export function mapToConstant(...entries) {
+ const numChoices = computeNumChoices(entries);
+ return nat({ max: numChoices - 1 }).map(indexToMappedConstantMapperFor(entries), indexToMappedConstantUnmapperFor(entries));
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/maxSafeInteger.js b/node_modules/fast-check/lib/esm/arbitrary/maxSafeInteger.js
new file mode 100644
index 0000000000000000000000000000000000000000..4d936792b15cfec0f93394ef0ec52f7fa173f6b9
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/maxSafeInteger.js
@@ -0,0 +1,6 @@
+import { IntegerArbitrary } from './_internals/IntegerArbitrary.js';
+const safeMinSafeInteger = Number.MIN_SAFE_INTEGER;
+const safeMaxSafeInteger = Number.MAX_SAFE_INTEGER;
+export function maxSafeInteger() {
+ return new IntegerArbitrary(safeMinSafeInteger, safeMaxSafeInteger);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/maxSafeNat.js b/node_modules/fast-check/lib/esm/arbitrary/maxSafeNat.js
new file mode 100644
index 0000000000000000000000000000000000000000..574e5c253c76def993cac34f08985ef8038ac435
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/maxSafeNat.js
@@ -0,0 +1,5 @@
+import { IntegerArbitrary } from './_internals/IntegerArbitrary.js';
+const safeMaxSafeInteger = Number.MAX_SAFE_INTEGER;
+export function maxSafeNat() {
+ return new IntegerArbitrary(0, safeMaxSafeInteger);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/memo.js b/node_modules/fast-check/lib/esm/arbitrary/memo.js
new file mode 100644
index 0000000000000000000000000000000000000000..0581f9cd4538712af335251e3a744b70cd04fa78
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/memo.js
@@ -0,0 +1,15 @@
+import { safeHasOwnProperty } from '../utils/globals.js';
+let contextRemainingDepth = 10;
+export function memo(builder) {
+ const previous = {};
+ return ((maxDepth) => {
+ const n = maxDepth !== undefined ? maxDepth : contextRemainingDepth;
+ if (!safeHasOwnProperty(previous, n)) {
+ const prev = contextRemainingDepth;
+ contextRemainingDepth = n - 1;
+ previous[n] = builder(n);
+ contextRemainingDepth = prev;
+ }
+ return previous[n];
+ });
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/mixedCase.js b/node_modules/fast-check/lib/esm/arbitrary/mixedCase.js
new file mode 100644
index 0000000000000000000000000000000000000000..00167d9c87e37cddf6864e4e34d4523d1ca31499
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/mixedCase.js
@@ -0,0 +1,16 @@
+import { safeToUpperCase, safeToLowerCase, BigInt, Error } from '../utils/globals.js';
+import { MixedCaseArbitrary } from './_internals/MixedCaseArbitrary.js';
+function defaultToggleCase(rawChar) {
+ const upper = safeToUpperCase(rawChar);
+ if (upper !== rawChar)
+ return upper;
+ return safeToLowerCase(rawChar);
+}
+export function mixedCase(stringArb, constraints) {
+ if (typeof BigInt === 'undefined') {
+ throw new Error(`mixedCase requires BigInt support`);
+ }
+ const toggleCase = (constraints && constraints.toggleCase) || defaultToggleCase;
+ const untoggleAll = constraints && constraints.untoggleAll;
+ return new MixedCaseArbitrary(stringArb, toggleCase, untoggleAll);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/nat.js b/node_modules/fast-check/lib/esm/arbitrary/nat.js
new file mode 100644
index 0000000000000000000000000000000000000000..76b10eae07c51c97dae25c6779e532b427101c6f
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/nat.js
@@ -0,0 +1,13 @@
+import { IntegerArbitrary } from './_internals/IntegerArbitrary.js';
+const safeNumberIsInteger = Number.isInteger;
+function nat(arg) {
+ const max = typeof arg === 'number' ? arg : arg && arg.max !== undefined ? arg.max : 0x7fffffff;
+ if (max < 0) {
+ throw new Error('fc.nat value should be greater than or equal to 0');
+ }
+ if (!safeNumberIsInteger(max)) {
+ throw new Error('fc.nat maximum value should be an integer');
+ }
+ return new IntegerArbitrary(0, max);
+}
+export { nat };
diff --git a/node_modules/fast-check/lib/esm/arbitrary/noBias.js b/node_modules/fast-check/lib/esm/arbitrary/noBias.js
new file mode 100644
index 0000000000000000000000000000000000000000..554e9b4c8ca2b2e68c241a1320246407f830570f
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/noBias.js
@@ -0,0 +1,3 @@
+export function noBias(arb) {
+ return arb.noBias();
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/noShrink.js b/node_modules/fast-check/lib/esm/arbitrary/noShrink.js
new file mode 100644
index 0000000000000000000000000000000000000000..736fe804af95844d5b51aeff3bfba55991747807
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/noShrink.js
@@ -0,0 +1,3 @@
+export function noShrink(arb) {
+ return arb.noShrink();
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/object.js b/node_modules/fast-check/lib/esm/arbitrary/object.js
new file mode 100644
index 0000000000000000000000000000000000000000..5c12185462115fd06b1ce25cb4de47897bc44457
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/object.js
@@ -0,0 +1,14 @@
+import { dictionary } from './dictionary.js';
+import { anyArbitraryBuilder } from './_internals/builders/AnyArbitraryBuilder.js';
+import { toQualifiedObjectConstraints } from './_internals/helpers/QualifiedObjectConstraints.js';
+function objectInternal(constraints) {
+ return dictionary(constraints.key, anyArbitraryBuilder(constraints), {
+ maxKeys: constraints.maxKeys,
+ noNullPrototype: !constraints.withNullPrototype,
+ size: constraints.size,
+ });
+}
+function object(constraints) {
+ return objectInternal(toQualifiedObjectConstraints(constraints));
+}
+export { object };
diff --git a/node_modules/fast-check/lib/esm/arbitrary/oneof.js b/node_modules/fast-check/lib/esm/arbitrary/oneof.js
new file mode 100644
index 0000000000000000000000000000000000000000..4c55f31de722331c3c86e6be90ed19c147df23e5
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/oneof.js
@@ -0,0 +1,26 @@
+import { isArbitrary } from '../check/arbitrary/definition/Arbitrary.js';
+import { safeMap, safeSlice } from '../utils/globals.js';
+import { FrequencyArbitrary } from './_internals/FrequencyArbitrary.js';
+function isOneOfContraints(param) {
+ return (param != null &&
+ typeof param === 'object' &&
+ !('generate' in param) &&
+ !('arbitrary' in param) &&
+ !('weight' in param));
+}
+function toWeightedArbitrary(maybeWeightedArbitrary) {
+ if (isArbitrary(maybeWeightedArbitrary)) {
+ return { arbitrary: maybeWeightedArbitrary, weight: 1 };
+ }
+ return maybeWeightedArbitrary;
+}
+function oneof(...args) {
+ const constraints = args[0];
+ if (isOneOfContraints(constraints)) {
+ const weightedArbs = safeMap(safeSlice(args, 1), toWeightedArbitrary);
+ return FrequencyArbitrary.from(weightedArbs, constraints, 'fc.oneof');
+ }
+ const weightedArbs = safeMap(args, toWeightedArbitrary);
+ return FrequencyArbitrary.from(weightedArbs, {}, 'fc.oneof');
+}
+export { oneof };
diff --git a/node_modules/fast-check/lib/esm/arbitrary/option.js b/node_modules/fast-check/lib/esm/arbitrary/option.js
new file mode 100644
index 0000000000000000000000000000000000000000..961931485d7cc903e47d579bb68954a028fbef4c
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/option.js
@@ -0,0 +1,19 @@
+import { constant } from './constant.js';
+import { FrequencyArbitrary } from './_internals/FrequencyArbitrary.js';
+import { safeHasOwnProperty } from '../utils/globals.js';
+export function option(arb, constraints = {}) {
+ const freq = constraints.freq == null ? 5 : constraints.freq;
+ const nilValue = safeHasOwnProperty(constraints, 'nil') ? constraints.nil : null;
+ const nilArb = constant(nilValue);
+ const weightedArbs = [
+ { arbitrary: nilArb, weight: 1, fallbackValue: { default: nilValue } },
+ { arbitrary: arb, weight: freq },
+ ];
+ const frequencyConstraints = {
+ withCrossShrink: true,
+ depthSize: constraints.depthSize,
+ maxDepth: constraints.maxDepth,
+ depthIdentifier: constraints.depthIdentifier,
+ };
+ return FrequencyArbitrary.from(weightedArbs, frequencyConstraints, 'fc.option');
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/record.js b/node_modules/fast-check/lib/esm/arbitrary/record.js
new file mode 100644
index 0000000000000000000000000000000000000000..f89278d9ca4e1ae30c5dcd56a2e3831ff269d20b
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/record.js
@@ -0,0 +1,27 @@
+import { buildPartialRecordArbitrary } from './_internals/builders/PartialRecordArbitraryBuilder.js';
+function record(recordModel, constraints) {
+ const noNullPrototype = constraints === undefined || constraints.noNullPrototype === undefined || constraints.noNullPrototype;
+ if (constraints == null) {
+ return buildPartialRecordArbitrary(recordModel, undefined, noNullPrototype);
+ }
+ if ('withDeletedKeys' in constraints && 'requiredKeys' in constraints) {
+ throw new Error(`requiredKeys and withDeletedKeys cannot be used together in fc.record`);
+ }
+ const requireDeletedKeys = ('requiredKeys' in constraints && constraints.requiredKeys !== undefined) ||
+ ('withDeletedKeys' in constraints && !!constraints.withDeletedKeys);
+ if (!requireDeletedKeys) {
+ return buildPartialRecordArbitrary(recordModel, undefined, noNullPrototype);
+ }
+ const requiredKeys = ('requiredKeys' in constraints ? constraints.requiredKeys : undefined) || [];
+ for (let idx = 0; idx !== requiredKeys.length; ++idx) {
+ const descriptor = Object.getOwnPropertyDescriptor(recordModel, requiredKeys[idx]);
+ if (descriptor === undefined) {
+ throw new Error(`requiredKeys cannot reference keys that have not been defined in recordModel`);
+ }
+ if (!descriptor.enumerable) {
+ throw new Error(`requiredKeys cannot reference keys that have are enumerable in recordModel`);
+ }
+ }
+ return buildPartialRecordArbitrary(recordModel, requiredKeys, noNullPrototype);
+}
+export { record };
diff --git a/node_modules/fast-check/lib/esm/arbitrary/scheduler.js b/node_modules/fast-check/lib/esm/arbitrary/scheduler.js
new file mode 100644
index 0000000000000000000000000000000000000000..865a0f06f7499548b9397074e6ceb5f691279715
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/scheduler.js
@@ -0,0 +1,18 @@
+import { buildSchedulerFor } from './_internals/helpers/BuildSchedulerFor.js';
+import { SchedulerArbitrary } from './_internals/SchedulerArbitrary.js';
+export function scheduler(constraints) {
+ const { act = (f) => f() } = constraints || {};
+ return new SchedulerArbitrary(act);
+}
+function schedulerFor(customOrderingOrConstraints, constraintsOrUndefined) {
+ const { act = (f) => f() } = Array.isArray(customOrderingOrConstraints)
+ ? constraintsOrUndefined || {}
+ : customOrderingOrConstraints || {};
+ if (Array.isArray(customOrderingOrConstraints)) {
+ return buildSchedulerFor(act, customOrderingOrConstraints);
+ }
+ return function (_strs, ...ordering) {
+ return buildSchedulerFor(act, ordering);
+ };
+}
+export { schedulerFor };
diff --git a/node_modules/fast-check/lib/esm/arbitrary/shuffledSubarray.js b/node_modules/fast-check/lib/esm/arbitrary/shuffledSubarray.js
new file mode 100644
index 0000000000000000000000000000000000000000..76b576b6b1e930de6a6feceb53073da48b58a15e
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/shuffledSubarray.js
@@ -0,0 +1,5 @@
+import { SubarrayArbitrary } from './_internals/SubarrayArbitrary.js';
+export function shuffledSubarray(originalArray, constraints = {}) {
+ const { minLength = 0, maxLength = originalArray.length } = constraints;
+ return new SubarrayArbitrary(originalArray, false, minLength, maxLength);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/sparseArray.js b/node_modules/fast-check/lib/esm/arbitrary/sparseArray.js
new file mode 100644
index 0000000000000000000000000000000000000000..1a78f121352317a59985b071aac1cd6fead68776
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/sparseArray.js
@@ -0,0 +1,76 @@
+import { Array, safeMap, safeSlice } from '../utils/globals.js';
+import { tuple } from './tuple.js';
+import { uniqueArray } from './uniqueArray.js';
+import { restrictedIntegerArbitraryBuilder } from './_internals/builders/RestrictedIntegerArbitraryBuilder.js';
+import { maxGeneratedLengthFromSizeForArbitrary, MaxLengthUpperBound, } from './_internals/helpers/MaxLengthFromMinLength.js';
+const safeMathMin = Math.min;
+const safeMathMax = Math.max;
+const safeArrayIsArray = Array.isArray;
+const safeObjectEntries = Object.entries;
+function extractMaxIndex(indexesAndValues) {
+ let maxIndex = -1;
+ for (let index = 0; index !== indexesAndValues.length; ++index) {
+ maxIndex = safeMathMax(maxIndex, indexesAndValues[index][0]);
+ }
+ return maxIndex;
+}
+function arrayFromItems(length, indexesAndValues) {
+ const array = Array(length);
+ for (let index = 0; index !== indexesAndValues.length; ++index) {
+ const it = indexesAndValues[index];
+ if (it[0] < length)
+ array[it[0]] = it[1];
+ }
+ return array;
+}
+export function sparseArray(arb, constraints = {}) {
+ const { size, minNumElements = 0, maxLength = MaxLengthUpperBound, maxNumElements = maxLength, noTrailingHole, depthIdentifier, } = constraints;
+ const maxGeneratedNumElements = maxGeneratedLengthFromSizeForArbitrary(size, minNumElements, maxNumElements, constraints.maxNumElements !== undefined);
+ const maxGeneratedLength = maxGeneratedLengthFromSizeForArbitrary(size, maxGeneratedNumElements, maxLength, constraints.maxLength !== undefined);
+ if (minNumElements > maxLength) {
+ throw new Error(`The minimal number of non-hole elements cannot be higher than the maximal length of the array`);
+ }
+ if (minNumElements > maxNumElements) {
+ throw new Error(`The minimal number of non-hole elements cannot be higher than the maximal number of non-holes`);
+ }
+ const resultedMaxNumElements = safeMathMin(maxNumElements, maxLength);
+ const resultedSizeMaxNumElements = constraints.maxNumElements !== undefined || size !== undefined ? size : '=';
+ const maxGeneratedIndexAuthorized = safeMathMax(maxGeneratedLength - 1, 0);
+ const maxIndexAuthorized = safeMathMax(maxLength - 1, 0);
+ const sparseArrayNoTrailingHole = uniqueArray(tuple(restrictedIntegerArbitraryBuilder(0, maxGeneratedIndexAuthorized, maxIndexAuthorized), arb), {
+ size: resultedSizeMaxNumElements,
+ minLength: minNumElements,
+ maxLength: resultedMaxNumElements,
+ selector: (item) => item[0],
+ depthIdentifier,
+ }).map((items) => {
+ const lastIndex = extractMaxIndex(items);
+ return arrayFromItems(lastIndex + 1, items);
+ }, (value) => {
+ if (!safeArrayIsArray(value)) {
+ throw new Error('Not supported entry type');
+ }
+ if (noTrailingHole && value.length !== 0 && !(value.length - 1 in value)) {
+ throw new Error('No trailing hole');
+ }
+ return safeMap(safeObjectEntries(value), (entry) => [Number(entry[0]), entry[1]]);
+ });
+ if (noTrailingHole || maxLength === minNumElements) {
+ return sparseArrayNoTrailingHole;
+ }
+ return tuple(sparseArrayNoTrailingHole, restrictedIntegerArbitraryBuilder(minNumElements, maxGeneratedLength, maxLength)).map((data) => {
+ const sparse = data[0];
+ const targetLength = data[1];
+ if (sparse.length >= targetLength) {
+ return sparse;
+ }
+ const longerSparse = safeSlice(sparse);
+ longerSparse.length = targetLength;
+ return longerSparse;
+ }, (value) => {
+ if (!safeArrayIsArray(value)) {
+ throw new Error('Not supported entry type');
+ }
+ return [value, value.length];
+ });
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/string.js b/node_modules/fast-check/lib/esm/arbitrary/string.js
new file mode 100644
index 0000000000000000000000000000000000000000..bb047e1fb3663d98855a3eefad063f495724803d
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/string.js
@@ -0,0 +1,32 @@
+import { array } from './array.js';
+import { createSlicesForString } from './_internals/helpers/SlicesForStringBuilder.js';
+import { stringUnit } from './_internals/StringUnitArbitrary.js';
+import { patternsToStringMapper, patternsToStringUnmapperFor } from './_internals/mappers/PatternsToString.js';
+const safeObjectAssign = Object.assign;
+function extractUnitArbitrary(constraints) {
+ if (typeof constraints.unit === 'object') {
+ return constraints.unit;
+ }
+ switch (constraints.unit) {
+ case 'grapheme':
+ return stringUnit('grapheme', 'full');
+ case 'grapheme-composite':
+ return stringUnit('composite', 'full');
+ case 'grapheme-ascii':
+ case undefined:
+ return stringUnit('grapheme', 'ascii');
+ case 'binary':
+ return stringUnit('binary', 'full');
+ case 'binary-ascii':
+ return stringUnit('binary', 'ascii');
+ }
+}
+export function string(constraints = {}) {
+ const charArbitrary = extractUnitArbitrary(constraints);
+ const unmapper = patternsToStringUnmapperFor(charArbitrary, constraints);
+ const experimentalCustomSlices = createSlicesForString(charArbitrary, constraints);
+ const enrichedConstraints = safeObjectAssign(safeObjectAssign({}, constraints), {
+ experimentalCustomSlices,
+ });
+ return array(charArbitrary, enrichedConstraints).map(patternsToStringMapper, unmapper);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/string16bits.js b/node_modules/fast-check/lib/esm/arbitrary/string16bits.js
new file mode 100644
index 0000000000000000000000000000000000000000..537fd03ee42dafae451daa3c68186f66201997d2
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/string16bits.js
@@ -0,0 +1,13 @@
+import { array } from './array.js';
+import { char16bits } from './char16bits.js';
+import { charsToStringMapper, charsToStringUnmapper } from './_internals/mappers/CharsToString.js';
+import { createSlicesForStringLegacy } from './_internals/helpers/SlicesForStringBuilder.js';
+const safeObjectAssign = Object.assign;
+export function string16bits(constraints = {}) {
+ const charArbitrary = char16bits();
+ const experimentalCustomSlices = createSlicesForStringLegacy(charArbitrary, charsToStringUnmapper);
+ const enrichedConstraints = safeObjectAssign(safeObjectAssign({}, constraints), {
+ experimentalCustomSlices,
+ });
+ return array(charArbitrary, enrichedConstraints).map(charsToStringMapper, charsToStringUnmapper);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/stringMatching.js b/node_modules/fast-check/lib/esm/arbitrary/stringMatching.js
new file mode 100644
index 0000000000000000000000000000000000000000..1ea621079f1a96a1c8d720bd191311a22a26dfdf
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/stringMatching.js
@@ -0,0 +1,152 @@
+import { safeCharCodeAt, safeEvery, safeJoin, safeSubstring, Error, safeIndexOf, safeMap } from '../utils/globals.js';
+import { stringify } from '../utils/stringify.js';
+import { addMissingDotStar } from './_internals/helpers/SanitizeRegexAst.js';
+import { tokenizeRegex } from './_internals/helpers/TokenizeRegex.js';
+import { char } from './char.js';
+import { constant } from './constant.js';
+import { constantFrom } from './constantFrom.js';
+import { integer } from './integer.js';
+import { oneof } from './oneof.js';
+import { stringOf } from './stringOf.js';
+import { tuple } from './tuple.js';
+const safeStringFromCodePoint = String.fromCodePoint;
+const wordChars = [...'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_'];
+const digitChars = [...'0123456789'];
+const spaceChars = [...' \t\r\n\v\f'];
+const newLineChars = [...'\r\n'];
+const terminatorChars = [...'\x1E\x15'];
+const newLineAndTerminatorChars = [...newLineChars, ...terminatorChars];
+const defaultChar = char();
+function raiseUnsupportedASTNode(astNode) {
+ return new Error(`Unsupported AST node! Received: ${stringify(astNode)}`);
+}
+function toMatchingArbitrary(astNode, constraints, flags) {
+ switch (astNode.type) {
+ case 'Char': {
+ if (astNode.kind === 'meta') {
+ switch (astNode.value) {
+ case '\\w': {
+ return constantFrom(...wordChars);
+ }
+ case '\\W': {
+ return defaultChar.filter((c) => safeIndexOf(wordChars, c) === -1);
+ }
+ case '\\d': {
+ return constantFrom(...digitChars);
+ }
+ case '\\D': {
+ return defaultChar.filter((c) => safeIndexOf(digitChars, c) === -1);
+ }
+ case '\\s': {
+ return constantFrom(...spaceChars);
+ }
+ case '\\S': {
+ return defaultChar.filter((c) => safeIndexOf(spaceChars, c) === -1);
+ }
+ case '\\b':
+ case '\\B': {
+ throw new Error(`Meta character ${astNode.value} not implemented yet!`);
+ }
+ case '.': {
+ const forbiddenChars = flags.dotAll ? terminatorChars : newLineAndTerminatorChars;
+ return defaultChar.filter((c) => safeIndexOf(forbiddenChars, c) === -1);
+ }
+ }
+ }
+ if (astNode.symbol === undefined) {
+ throw new Error(`Unexpected undefined symbol received for non-meta Char! Received: ${stringify(astNode)}`);
+ }
+ return constant(astNode.symbol);
+ }
+ case 'Repetition': {
+ const node = toMatchingArbitrary(astNode.expression, constraints, flags);
+ switch (astNode.quantifier.kind) {
+ case '*': {
+ return stringOf(node, constraints);
+ }
+ case '+': {
+ return stringOf(node, Object.assign(Object.assign({}, constraints), { minLength: 1 }));
+ }
+ case '?': {
+ return stringOf(node, Object.assign(Object.assign({}, constraints), { minLength: 0, maxLength: 1 }));
+ }
+ case 'Range': {
+ return stringOf(node, Object.assign(Object.assign({}, constraints), { minLength: astNode.quantifier.from, maxLength: astNode.quantifier.to }));
+ }
+ default: {
+ throw raiseUnsupportedASTNode(astNode.quantifier);
+ }
+ }
+ }
+ case 'Quantifier': {
+ throw new Error(`Wrongly defined AST tree, Quantifier nodes not supposed to be scanned!`);
+ }
+ case 'Alternative': {
+ return tuple(...safeMap(astNode.expressions, (n) => toMatchingArbitrary(n, constraints, flags))).map((vs) => safeJoin(vs, ''));
+ }
+ case 'CharacterClass':
+ if (astNode.negative) {
+ const childrenArbitraries = safeMap(astNode.expressions, (n) => toMatchingArbitrary(n, constraints, flags));
+ return defaultChar.filter((c) => safeEvery(childrenArbitraries, (arb) => !arb.canShrinkWithoutContext(c)));
+ }
+ return oneof(...safeMap(astNode.expressions, (n) => toMatchingArbitrary(n, constraints, flags)));
+ case 'ClassRange': {
+ const min = astNode.from.codePoint;
+ const max = astNode.to.codePoint;
+ return integer({ min, max }).map((n) => safeStringFromCodePoint(n), (c) => {
+ if (typeof c !== 'string')
+ throw new Error('Invalid type');
+ if ([...c].length !== 1)
+ throw new Error('Invalid length');
+ return safeCharCodeAt(c, 0);
+ });
+ }
+ case 'Group': {
+ return toMatchingArbitrary(astNode.expression, constraints, flags);
+ }
+ case 'Disjunction': {
+ const left = astNode.left !== null ? toMatchingArbitrary(astNode.left, constraints, flags) : constant('');
+ const right = astNode.right !== null ? toMatchingArbitrary(astNode.right, constraints, flags) : constant('');
+ return oneof(left, right);
+ }
+ case 'Assertion': {
+ if (astNode.kind === '^' || astNode.kind === '$') {
+ if (flags.multiline) {
+ if (astNode.kind === '^') {
+ return oneof(constant(''), tuple(stringOf(defaultChar), constantFrom(...newLineChars)).map((t) => `${t[0]}${t[1]}`, (value) => {
+ if (typeof value !== 'string' || value.length === 0)
+ throw new Error('Invalid type');
+ return [safeSubstring(value, 0, value.length - 1), value[value.length - 1]];
+ }));
+ }
+ else {
+ return oneof(constant(''), tuple(constantFrom(...newLineChars), stringOf(defaultChar)).map((t) => `${t[0]}${t[1]}`, (value) => {
+ if (typeof value !== 'string' || value.length === 0)
+ throw new Error('Invalid type');
+ return [value[0], safeSubstring(value, 1)];
+ }));
+ }
+ }
+ return constant('');
+ }
+ throw new Error(`Assertions of kind ${astNode.kind} not implemented yet!`);
+ }
+ case 'Backreference': {
+ throw new Error(`Backreference nodes not implemented yet!`);
+ }
+ default: {
+ throw raiseUnsupportedASTNode(astNode);
+ }
+ }
+}
+export function stringMatching(regex, constraints = {}) {
+ for (const flag of regex.flags) {
+ if (flag !== 'd' && flag !== 'g' && flag !== 'm' && flag !== 's' && flag !== 'u') {
+ throw new Error(`Unable to use "stringMatching" against a regex using the flag ${flag}`);
+ }
+ }
+ const sanitizedConstraints = { size: constraints.size };
+ const flags = { multiline: regex.multiline, dotAll: regex.dotAll };
+ const regexRootToken = addMissingDotStar(tokenizeRegex(regex));
+ return toMatchingArbitrary(regexRootToken, sanitizedConstraints, flags);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/stringOf.js b/node_modules/fast-check/lib/esm/arbitrary/stringOf.js
new file mode 100644
index 0000000000000000000000000000000000000000..82e9925f0258a83c696a63d1904bf8fad62ec060
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/stringOf.js
@@ -0,0 +1,12 @@
+import { array } from './array.js';
+import { patternsToStringMapper, patternsToStringUnmapperFor } from './_internals/mappers/PatternsToString.js';
+import { createSlicesForStringLegacy } from './_internals/helpers/SlicesForStringBuilder.js';
+const safeObjectAssign = Object.assign;
+export function stringOf(charArb, constraints = {}) {
+ const unmapper = patternsToStringUnmapperFor(charArb, constraints);
+ const experimentalCustomSlices = createSlicesForStringLegacy(charArb, unmapper);
+ const enrichedConstraints = safeObjectAssign(safeObjectAssign({}, constraints), {
+ experimentalCustomSlices,
+ });
+ return array(charArb, enrichedConstraints).map(patternsToStringMapper, unmapper);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/subarray.js b/node_modules/fast-check/lib/esm/arbitrary/subarray.js
new file mode 100644
index 0000000000000000000000000000000000000000..7bd6b6214f354964a78f89b8d2fb16e08de62354
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/subarray.js
@@ -0,0 +1,5 @@
+import { SubarrayArbitrary } from './_internals/SubarrayArbitrary.js';
+export function subarray(originalArray, constraints = {}) {
+ const { minLength = 0, maxLength = originalArray.length } = constraints;
+ return new SubarrayArbitrary(originalArray, true, minLength, maxLength);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/tuple.js b/node_modules/fast-check/lib/esm/arbitrary/tuple.js
new file mode 100644
index 0000000000000000000000000000000000000000..70d9e8e7d35e51a9394a43a999516993300f8475
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/tuple.js
@@ -0,0 +1,4 @@
+import { TupleArbitrary } from './_internals/TupleArbitrary.js';
+export function tuple(...arbs) {
+ return new TupleArbitrary(arbs);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/uint16Array.js b/node_modules/fast-check/lib/esm/arbitrary/uint16Array.js
new file mode 100644
index 0000000000000000000000000000000000000000..ae30fcd0f7e7c6c390ce6837b6dc963d105f0288
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/uint16Array.js
@@ -0,0 +1,6 @@
+import { Uint16Array } from '../utils/globals.js';
+import { integer } from './integer.js';
+import { typedIntArrayArbitraryArbitraryBuilder } from './_internals/builders/TypedIntArrayArbitraryBuilder.js';
+export function uint16Array(constraints = {}) {
+ return typedIntArrayArbitraryArbitraryBuilder(constraints, 0, 65535, Uint16Array, integer);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/uint32Array.js b/node_modules/fast-check/lib/esm/arbitrary/uint32Array.js
new file mode 100644
index 0000000000000000000000000000000000000000..00511fdb0a2b4e93263f6654d7e73845b9d84bc6
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/uint32Array.js
@@ -0,0 +1,6 @@
+import { Uint32Array } from '../utils/globals.js';
+import { integer } from './integer.js';
+import { typedIntArrayArbitraryArbitraryBuilder } from './_internals/builders/TypedIntArrayArbitraryBuilder.js';
+export function uint32Array(constraints = {}) {
+ return typedIntArrayArbitraryArbitraryBuilder(constraints, 0, 0xffffffff, Uint32Array, integer);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/uint8Array.js b/node_modules/fast-check/lib/esm/arbitrary/uint8Array.js
new file mode 100644
index 0000000000000000000000000000000000000000..6ec6ac99a5fc1bddb488fdcff1ca676f11b7cfea
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/uint8Array.js
@@ -0,0 +1,6 @@
+import { Uint8Array } from '../utils/globals.js';
+import { integer } from './integer.js';
+import { typedIntArrayArbitraryArbitraryBuilder } from './_internals/builders/TypedIntArrayArbitraryBuilder.js';
+export function uint8Array(constraints = {}) {
+ return typedIntArrayArbitraryArbitraryBuilder(constraints, 0, 255, Uint8Array, integer);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/uint8ClampedArray.js b/node_modules/fast-check/lib/esm/arbitrary/uint8ClampedArray.js
new file mode 100644
index 0000000000000000000000000000000000000000..086a0a4c8b7bcfeb770cecd75979aff4f22c9d20
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/uint8ClampedArray.js
@@ -0,0 +1,6 @@
+import { Uint8ClampedArray } from '../utils/globals.js';
+import { integer } from './integer.js';
+import { typedIntArrayArbitraryArbitraryBuilder } from './_internals/builders/TypedIntArrayArbitraryBuilder.js';
+export function uint8ClampedArray(constraints = {}) {
+ return typedIntArrayArbitraryArbitraryBuilder(constraints, 0, 255, Uint8ClampedArray, integer);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/ulid.js b/node_modules/fast-check/lib/esm/arbitrary/ulid.js
new file mode 100644
index 0000000000000000000000000000000000000000..33e8506eea95c8e175e3ed0d8d392e4a7c994a0f
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/ulid.js
@@ -0,0 +1,26 @@
+import { tuple } from './tuple.js';
+import { integer } from './integer.js';
+import { paddedUintToBase32StringMapper, uintToBase32StringUnmapper } from './_internals/mappers/UintToBase32String.js';
+const padded10Mapper = paddedUintToBase32StringMapper(10);
+const padded8Mapper = paddedUintToBase32StringMapper(8);
+function ulidMapper(parts) {
+ return (padded10Mapper(parts[0]) +
+ padded8Mapper(parts[1]) +
+ padded8Mapper(parts[2]));
+}
+function ulidUnmapper(value) {
+ if (typeof value !== 'string' || value.length !== 26) {
+ throw new Error('Unsupported type');
+ }
+ return [
+ uintToBase32StringUnmapper(value.slice(0, 10)),
+ uintToBase32StringUnmapper(value.slice(10, 18)),
+ uintToBase32StringUnmapper(value.slice(18)),
+ ];
+}
+export function ulid() {
+ const timestampPartArbitrary = integer({ min: 0, max: 0xffffffffffff });
+ const randomnessPartOneArbitrary = integer({ min: 0, max: 0xffffffffff });
+ const randomnessPartTwoArbitrary = integer({ min: 0, max: 0xffffffffff });
+ return tuple(timestampPartArbitrary, randomnessPartOneArbitrary, randomnessPartTwoArbitrary).map(ulidMapper, ulidUnmapper);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/unicode.js b/node_modules/fast-check/lib/esm/arbitrary/unicode.js
new file mode 100644
index 0000000000000000000000000000000000000000..2a93cb89ededb6ec7cc596e3c6ea8eb5217e0768
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/unicode.js
@@ -0,0 +1,18 @@
+import { buildCharacterArbitrary } from './_internals/builders/CharacterArbitraryBuilder.js';
+import { indexToPrintableIndexMapper, indexToPrintableIndexUnmapper } from './_internals/mappers/IndexToPrintableIndex.js';
+const gapSize = 0xdfff + 1 - 0xd800;
+function unicodeMapper(v) {
+ if (v < 0xd800)
+ return indexToPrintableIndexMapper(v);
+ return v + gapSize;
+}
+function unicodeUnmapper(v) {
+ if (v < 0xd800)
+ return indexToPrintableIndexUnmapper(v);
+ if (v <= 0xdfff)
+ return -1;
+ return v - gapSize;
+}
+export function unicode() {
+ return buildCharacterArbitrary(0x0000, 0xffff - gapSize, unicodeMapper, unicodeUnmapper);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/unicodeJson.js b/node_modules/fast-check/lib/esm/arbitrary/unicodeJson.js
new file mode 100644
index 0000000000000000000000000000000000000000..fb4a1e4a5c481b762e3ee87d4aac04ab4e970804
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/unicodeJson.js
@@ -0,0 +1,5 @@
+import { unicodeJsonValue } from './unicodeJsonValue.js';
+export function unicodeJson(constraints = {}) {
+ const arb = unicodeJsonValue(constraints);
+ return arb.map(JSON.stringify);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/unicodeJsonValue.js b/node_modules/fast-check/lib/esm/arbitrary/unicodeJsonValue.js
new file mode 100644
index 0000000000000000000000000000000000000000..fe39a3a984686899bca2b3514bc6100bf1b09bd6
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/unicodeJsonValue.js
@@ -0,0 +1,6 @@
+import { unicodeString } from './unicodeString.js';
+import { jsonConstraintsBuilder } from './_internals/helpers/JsonConstraintsBuilder.js';
+import { anything } from './anything.js';
+export function unicodeJsonValue(constraints = {}) {
+ return anything(jsonConstraintsBuilder(unicodeString(), constraints));
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/unicodeString.js b/node_modules/fast-check/lib/esm/arbitrary/unicodeString.js
new file mode 100644
index 0000000000000000000000000000000000000000..b25d7fb3ff0f8284b1577eead09ee1d54734a536
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/unicodeString.js
@@ -0,0 +1,13 @@
+import { array } from './array.js';
+import { unicode } from './unicode.js';
+import { codePointsToStringMapper, codePointsToStringUnmapper } from './_internals/mappers/CodePointsToString.js';
+import { createSlicesForStringLegacy } from './_internals/helpers/SlicesForStringBuilder.js';
+const safeObjectAssign = Object.assign;
+export function unicodeString(constraints = {}) {
+ const charArbitrary = unicode();
+ const experimentalCustomSlices = createSlicesForStringLegacy(charArbitrary, codePointsToStringUnmapper);
+ const enrichedConstraints = safeObjectAssign(safeObjectAssign({}, constraints), {
+ experimentalCustomSlices,
+ });
+ return array(charArbitrary, enrichedConstraints).map(codePointsToStringMapper, codePointsToStringUnmapper);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/uniqueArray.js b/node_modules/fast-check/lib/esm/arbitrary/uniqueArray.js
new file mode 100644
index 0000000000000000000000000000000000000000..04ee86a43375a7b57846e9baf19548f43b8a01c2
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/uniqueArray.js
@@ -0,0 +1,42 @@
+import { ArrayArbitrary } from './_internals/ArrayArbitrary.js';
+import { maxGeneratedLengthFromSizeForArbitrary, MaxLengthUpperBound, } from './_internals/helpers/MaxLengthFromMinLength.js';
+import { CustomEqualSet } from './_internals/helpers/CustomEqualSet.js';
+import { StrictlyEqualSet } from './_internals/helpers/StrictlyEqualSet.js';
+import { SameValueSet } from './_internals/helpers/SameValueSet.js';
+import { SameValueZeroSet } from './_internals/helpers/SameValueZeroSet.js';
+function buildUniqueArraySetBuilder(constraints) {
+ if (typeof constraints.comparator === 'function') {
+ if (constraints.selector === undefined) {
+ const comparator = constraints.comparator;
+ const isEqualForBuilder = (nextA, nextB) => comparator(nextA.value_, nextB.value_);
+ return () => new CustomEqualSet(isEqualForBuilder);
+ }
+ const comparator = constraints.comparator;
+ const selector = constraints.selector;
+ const refinedSelector = (next) => selector(next.value_);
+ const isEqualForBuilder = (nextA, nextB) => comparator(refinedSelector(nextA), refinedSelector(nextB));
+ return () => new CustomEqualSet(isEqualForBuilder);
+ }
+ const selector = constraints.selector || ((v) => v);
+ const refinedSelector = (next) => selector(next.value_);
+ switch (constraints.comparator) {
+ case 'IsStrictlyEqual':
+ return () => new StrictlyEqualSet(refinedSelector);
+ case 'SameValueZero':
+ return () => new SameValueZeroSet(refinedSelector);
+ case 'SameValue':
+ case undefined:
+ return () => new SameValueSet(refinedSelector);
+ }
+}
+export function uniqueArray(arb, constraints = {}) {
+ const minLength = constraints.minLength !== undefined ? constraints.minLength : 0;
+ const maxLength = constraints.maxLength !== undefined ? constraints.maxLength : MaxLengthUpperBound;
+ const maxGeneratedLength = maxGeneratedLengthFromSizeForArbitrary(constraints.size, minLength, maxLength, constraints.maxLength !== undefined);
+ const depthIdentifier = constraints.depthIdentifier;
+ const setBuilder = buildUniqueArraySetBuilder(constraints);
+ const arrayArb = new ArrayArbitrary(arb, minLength, maxGeneratedLength, maxLength, depthIdentifier, setBuilder, []);
+ if (minLength === 0)
+ return arrayArb;
+ return arrayArb.filter((tab) => tab.length >= minLength);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/uuid.js b/node_modules/fast-check/lib/esm/arbitrary/uuid.js
new file mode 100644
index 0000000000000000000000000000000000000000..a5e3aa62878237dd050b502f302f5e37d5ffde58
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/uuid.js
@@ -0,0 +1,36 @@
+import { tuple } from './tuple.js';
+import { buildPaddedNumberArbitrary } from './_internals/builders/PaddedNumberArbitraryBuilder.js';
+import { paddedEightsToUuidMapper, paddedEightsToUuidUnmapper } from './_internals/mappers/PaddedEightsToUuid.js';
+import { Error } from '../utils/globals.js';
+import { buildVersionsAppliersForUuid } from './_internals/mappers/VersionsApplierForUuid.js';
+function assertValidVersions(versions) {
+ const found = {};
+ for (const version of versions) {
+ if (found[version]) {
+ throw new Error(`Version ${version} has been requested at least twice for uuid`);
+ }
+ found[version] = true;
+ if (version < 1 || version > 15) {
+ throw new Error(`Version must be a value in [1-15] for uuid, but received ${version}`);
+ }
+ if (~~version !== version) {
+ throw new Error(`Version must be an integer value for uuid, but received ${version}`);
+ }
+ }
+ if (versions.length === 0) {
+ throw new Error(`Must provide at least one version for uuid`);
+ }
+}
+export function uuid(constraints = {}) {
+ const padded = buildPaddedNumberArbitrary(0, 0xffffffff);
+ const version = constraints.version !== undefined
+ ? typeof constraints.version === 'number'
+ ? [constraints.version]
+ : constraints.version
+ : [1, 2, 3, 4, 5];
+ assertValidVersions(version);
+ const { versionsApplierMapper, versionsApplierUnmapper } = buildVersionsAppliersForUuid(version);
+ const secondPadded = buildPaddedNumberArbitrary(0, 0x10000000 * version.length - 1).map(versionsApplierMapper, versionsApplierUnmapper);
+ const thirdPadded = buildPaddedNumberArbitrary(0x80000000, 0xbfffffff);
+ return tuple(padded, secondPadded, thirdPadded, padded).map(paddedEightsToUuidMapper, paddedEightsToUuidUnmapper);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/uuidV.js b/node_modules/fast-check/lib/esm/arbitrary/uuidV.js
new file mode 100644
index 0000000000000000000000000000000000000000..0de38b14878f208f00e334f8fa2e216db1aa11d2
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/uuidV.js
@@ -0,0 +1,10 @@
+import { tuple } from './tuple.js';
+import { buildPaddedNumberArbitrary } from './_internals/builders/PaddedNumberArbitraryBuilder.js';
+import { paddedEightsToUuidMapper, paddedEightsToUuidUnmapper } from './_internals/mappers/PaddedEightsToUuid.js';
+export function uuidV(versionNumber) {
+ const padded = buildPaddedNumberArbitrary(0, 0xffffffff);
+ const offsetSecond = versionNumber * 0x10000000;
+ const secondPadded = buildPaddedNumberArbitrary(offsetSecond, offsetSecond + 0x0fffffff);
+ const thirdPadded = buildPaddedNumberArbitrary(0x80000000, 0xbfffffff);
+ return tuple(padded, secondPadded, thirdPadded, padded).map(paddedEightsToUuidMapper, paddedEightsToUuidUnmapper);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/webAuthority.js b/node_modules/fast-check/lib/esm/arbitrary/webAuthority.js
new file mode 100644
index 0000000000000000000000000000000000000000..12d3e402f6abdb166658cc897cac0be0273926c0
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/webAuthority.js
@@ -0,0 +1,49 @@
+import { getOrCreateAlphaNumericPercentArbitrary } from './_internals/builders/CharacterRangeArbitraryBuilder.js';
+import { constant } from './constant.js';
+import { domain } from './domain.js';
+import { ipV4 } from './ipV4.js';
+import { ipV4Extended } from './ipV4Extended.js';
+import { ipV6 } from './ipV6.js';
+import { nat } from './nat.js';
+import { oneof } from './oneof.js';
+import { option } from './option.js';
+import { string } from './string.js';
+import { tuple } from './tuple.js';
+function hostUserInfo(size) {
+ return string({ unit: getOrCreateAlphaNumericPercentArbitrary("-._~!$&'()*+,;=:"), size });
+}
+function userHostPortMapper([u, h, p]) {
+ return (u === null ? '' : `${u}@`) + h + (p === null ? '' : `:${p}`);
+}
+function userHostPortUnmapper(value) {
+ if (typeof value !== 'string') {
+ throw new Error('Unsupported');
+ }
+ const atPosition = value.indexOf('@');
+ const user = atPosition !== -1 ? value.substring(0, atPosition) : null;
+ const portRegex = /:(\d+)$/;
+ const m = portRegex.exec(value);
+ const port = m !== null ? Number(m[1]) : null;
+ const host = m !== null ? value.substring(atPosition + 1, value.length - m[1].length - 1) : value.substring(atPosition + 1);
+ return [user, host, port];
+}
+function bracketedMapper(s) {
+ return `[${s}]`;
+}
+function bracketedUnmapper(value) {
+ if (typeof value !== 'string' || value[0] !== '[' || value[value.length - 1] !== ']') {
+ throw new Error('Unsupported');
+ }
+ return value.substring(1, value.length - 1);
+}
+export function webAuthority(constraints) {
+ const c = constraints || {};
+ const size = c.size;
+ const hostnameArbs = [
+ domain({ size }),
+ ...(c.withIPv4 === true ? [ipV4()] : []),
+ ...(c.withIPv6 === true ? [ipV6().map(bracketedMapper, bracketedUnmapper)] : []),
+ ...(c.withIPv4Extended === true ? [ipV4Extended()] : []),
+ ];
+ return tuple(c.withUserInfo === true ? option(hostUserInfo(size)) : constant(null), oneof(...hostnameArbs), c.withPort === true ? option(nat(65535)) : constant(null)).map(userHostPortMapper, userHostPortUnmapper);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/webFragments.js b/node_modules/fast-check/lib/esm/arbitrary/webFragments.js
new file mode 100644
index 0000000000000000000000000000000000000000..d89af190f9b03f1736c8912fbe0312b457913081
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/webFragments.js
@@ -0,0 +1,4 @@
+import { buildUriQueryOrFragmentArbitrary } from './_internals/builders/UriQueryOrFragmentArbitraryBuilder.js';
+export function webFragments(constraints = {}) {
+ return buildUriQueryOrFragmentArbitrary(constraints.size);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/webPath.js b/node_modules/fast-check/lib/esm/arbitrary/webPath.js
new file mode 100644
index 0000000000000000000000000000000000000000..d79a49c46237da7ccf05b3f9e158d37ddf3ef66f
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/webPath.js
@@ -0,0 +1,7 @@
+import { resolveSize } from './_internals/helpers/MaxLengthFromMinLength.js';
+import { buildUriPathArbitrary } from './_internals/builders/UriPathArbitraryBuilder.js';
+export function webPath(constraints) {
+ const c = constraints || {};
+ const resolvedSize = resolveSize(c.size);
+ return buildUriPathArbitrary(resolvedSize);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/webQueryParameters.js b/node_modules/fast-check/lib/esm/arbitrary/webQueryParameters.js
new file mode 100644
index 0000000000000000000000000000000000000000..509a632eb36ad2fb72873ce40d83ddd9b5ac74a6
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/webQueryParameters.js
@@ -0,0 +1,4 @@
+import { buildUriQueryOrFragmentArbitrary } from './_internals/builders/UriQueryOrFragmentArbitraryBuilder.js';
+export function webQueryParameters(constraints = {}) {
+ return buildUriQueryOrFragmentArbitrary(constraints.size);
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/webSegment.js b/node_modules/fast-check/lib/esm/arbitrary/webSegment.js
new file mode 100644
index 0000000000000000000000000000000000000000..2ecd6ec95e72a356ed1700d6daa4cadb47859ade
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/webSegment.js
@@ -0,0 +1,5 @@
+import { getOrCreateAlphaNumericPercentArbitrary } from './_internals/builders/CharacterRangeArbitraryBuilder.js';
+import { string } from './string.js';
+export function webSegment(constraints = {}) {
+ return string({ unit: getOrCreateAlphaNumericPercentArbitrary("-._~!$&'()*+,;=:@"), size: constraints.size });
+}
diff --git a/node_modules/fast-check/lib/esm/arbitrary/webUrl.js b/node_modules/fast-check/lib/esm/arbitrary/webUrl.js
new file mode 100644
index 0000000000000000000000000000000000000000..ee46ac44f3e5f7ff6cda7614a7c7dc916a0b770b
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/arbitrary/webUrl.js
@@ -0,0 +1,25 @@
+import { constantFrom } from './constantFrom.js';
+import { constant } from './constant.js';
+import { option } from './option.js';
+import { tuple } from './tuple.js';
+import { webQueryParameters } from './webQueryParameters.js';
+import { webFragments } from './webFragments.js';
+import { webAuthority } from './webAuthority.js';
+import { partsToUrlMapper, partsToUrlUnmapper } from './_internals/mappers/PartsToUrl.js';
+import { relativeSizeToSize, resolveSize } from './_internals/helpers/MaxLengthFromMinLength.js';
+import { webPath } from './webPath.js';
+const safeObjectAssign = Object.assign;
+export function webUrl(constraints) {
+ const c = constraints || {};
+ const resolvedSize = resolveSize(c.size);
+ const resolvedAuthoritySettingsSize = c.authoritySettings !== undefined && c.authoritySettings.size !== undefined
+ ? relativeSizeToSize(c.authoritySettings.size, resolvedSize)
+ : resolvedSize;
+ const resolvedAuthoritySettings = safeObjectAssign(safeObjectAssign({}, c.authoritySettings), {
+ size: resolvedAuthoritySettingsSize,
+ });
+ const validSchemes = c.validSchemes || ['http', 'https'];
+ const schemeArb = constantFrom(...validSchemes);
+ const authorityArb = webAuthority(resolvedAuthoritySettings);
+ return tuple(schemeArb, authorityArb, webPath({ size: resolvedSize }), c.withQueryParameters === true ? option(webQueryParameters({ size: resolvedSize })) : constant(null), c.withFragments === true ? option(webFragments({ size: resolvedSize })) : constant(null)).map(partsToUrlMapper, partsToUrlUnmapper);
+}
diff --git a/node_modules/fast-check/lib/esm/check/arbitrary/definition/Arbitrary.js b/node_modules/fast-check/lib/esm/check/arbitrary/definition/Arbitrary.js
new file mode 100644
index 0000000000000000000000000000000000000000..6aa23fc72f0e4658159d9ad3bceba4bdcbca1ebc
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/check/arbitrary/definition/Arbitrary.js
@@ -0,0 +1,207 @@
+import { Stream } from '../../../stream/Stream.js';
+import { cloneMethod, hasCloneMethod } from '../../symbols.js';
+import { Value } from './Value.js';
+const safeObjectAssign = Object.assign;
+export class Arbitrary {
+ filter(refinement) {
+ return new FilterArbitrary(this, refinement);
+ }
+ map(mapper, unmapper) {
+ return new MapArbitrary(this, mapper, unmapper);
+ }
+ chain(chainer) {
+ return new ChainArbitrary(this, chainer);
+ }
+ noShrink() {
+ return new NoShrinkArbitrary(this);
+ }
+ noBias() {
+ return new NoBiasArbitrary(this);
+ }
+}
+class ChainArbitrary extends Arbitrary {
+ constructor(arb, chainer) {
+ super();
+ this.arb = arb;
+ this.chainer = chainer;
+ }
+ generate(mrng, biasFactor) {
+ const clonedMrng = mrng.clone();
+ const src = this.arb.generate(mrng, biasFactor);
+ return this.valueChainer(src, mrng, clonedMrng, biasFactor);
+ }
+ canShrinkWithoutContext(value) {
+ return false;
+ }
+ shrink(value, context) {
+ if (this.isSafeContext(context)) {
+ return (!context.stoppedForOriginal
+ ? this.arb
+ .shrink(context.originalValue, context.originalContext)
+ .map((v) => this.valueChainer(v, context.clonedMrng.clone(), context.clonedMrng, context.originalBias))
+ : Stream.nil()).join(context.chainedArbitrary.shrink(value, context.chainedContext).map((dst) => {
+ const newContext = safeObjectAssign(safeObjectAssign({}, context), {
+ chainedContext: dst.context,
+ stoppedForOriginal: true,
+ });
+ return new Value(dst.value_, newContext);
+ }));
+ }
+ return Stream.nil();
+ }
+ valueChainer(v, generateMrng, clonedMrng, biasFactor) {
+ const chainedArbitrary = this.chainer(v.value_);
+ const dst = chainedArbitrary.generate(generateMrng, biasFactor);
+ const context = {
+ originalBias: biasFactor,
+ originalValue: v.value_,
+ originalContext: v.context,
+ stoppedForOriginal: false,
+ chainedArbitrary,
+ chainedContext: dst.context,
+ clonedMrng,
+ };
+ return new Value(dst.value_, context);
+ }
+ isSafeContext(context) {
+ return (context != null &&
+ typeof context === 'object' &&
+ 'originalBias' in context &&
+ 'originalValue' in context &&
+ 'originalContext' in context &&
+ 'stoppedForOriginal' in context &&
+ 'chainedArbitrary' in context &&
+ 'chainedContext' in context &&
+ 'clonedMrng' in context);
+ }
+}
+class MapArbitrary extends Arbitrary {
+ constructor(arb, mapper, unmapper) {
+ super();
+ this.arb = arb;
+ this.mapper = mapper;
+ this.unmapper = unmapper;
+ this.bindValueMapper = (v) => this.valueMapper(v);
+ }
+ generate(mrng, biasFactor) {
+ const g = this.arb.generate(mrng, biasFactor);
+ return this.valueMapper(g);
+ }
+ canShrinkWithoutContext(value) {
+ if (this.unmapper !== undefined) {
+ try {
+ const unmapped = this.unmapper(value);
+ return this.arb.canShrinkWithoutContext(unmapped);
+ }
+ catch (_err) {
+ return false;
+ }
+ }
+ return false;
+ }
+ shrink(value, context) {
+ if (this.isSafeContext(context)) {
+ return this.arb.shrink(context.originalValue, context.originalContext).map(this.bindValueMapper);
+ }
+ if (this.unmapper !== undefined) {
+ const unmapped = this.unmapper(value);
+ return this.arb.shrink(unmapped, undefined).map(this.bindValueMapper);
+ }
+ return Stream.nil();
+ }
+ mapperWithCloneIfNeeded(v) {
+ const sourceValue = v.value;
+ const mappedValue = this.mapper(sourceValue);
+ if (v.hasToBeCloned &&
+ ((typeof mappedValue === 'object' && mappedValue !== null) || typeof mappedValue === 'function') &&
+ Object.isExtensible(mappedValue) &&
+ !hasCloneMethod(mappedValue)) {
+ Object.defineProperty(mappedValue, cloneMethod, { get: () => () => this.mapperWithCloneIfNeeded(v)[0] });
+ }
+ return [mappedValue, sourceValue];
+ }
+ valueMapper(v) {
+ const [mappedValue, sourceValue] = this.mapperWithCloneIfNeeded(v);
+ const context = { originalValue: sourceValue, originalContext: v.context };
+ return new Value(mappedValue, context);
+ }
+ isSafeContext(context) {
+ return (context != null &&
+ typeof context === 'object' &&
+ 'originalValue' in context &&
+ 'originalContext' in context);
+ }
+}
+class FilterArbitrary extends Arbitrary {
+ constructor(arb, refinement) {
+ super();
+ this.arb = arb;
+ this.refinement = refinement;
+ this.bindRefinementOnValue = (v) => this.refinementOnValue(v);
+ }
+ generate(mrng, biasFactor) {
+ while (true) {
+ const g = this.arb.generate(mrng, biasFactor);
+ if (this.refinementOnValue(g)) {
+ return g;
+ }
+ }
+ }
+ canShrinkWithoutContext(value) {
+ return this.arb.canShrinkWithoutContext(value) && this.refinement(value);
+ }
+ shrink(value, context) {
+ return this.arb.shrink(value, context).filter(this.bindRefinementOnValue);
+ }
+ refinementOnValue(v) {
+ return this.refinement(v.value);
+ }
+}
+class NoShrinkArbitrary extends Arbitrary {
+ constructor(arb) {
+ super();
+ this.arb = arb;
+ }
+ generate(mrng, biasFactor) {
+ return this.arb.generate(mrng, biasFactor);
+ }
+ canShrinkWithoutContext(value) {
+ return this.arb.canShrinkWithoutContext(value);
+ }
+ shrink(_value, _context) {
+ return Stream.nil();
+ }
+ noShrink() {
+ return this;
+ }
+}
+class NoBiasArbitrary extends Arbitrary {
+ constructor(arb) {
+ super();
+ this.arb = arb;
+ }
+ generate(mrng, _biasFactor) {
+ return this.arb.generate(mrng, undefined);
+ }
+ canShrinkWithoutContext(value) {
+ return this.arb.canShrinkWithoutContext(value);
+ }
+ shrink(value, context) {
+ return this.arb.shrink(value, context);
+ }
+ noBias() {
+ return this;
+ }
+}
+export function isArbitrary(instance) {
+ return (typeof instance === 'object' &&
+ instance !== null &&
+ 'generate' in instance &&
+ 'shrink' in instance &&
+ 'canShrinkWithoutContext' in instance);
+}
+export function assertIsArbitrary(instance) {
+ if (!isArbitrary(instance)) {
+ throw new Error('Unexpected value received: not an instance of Arbitrary');
+ }
+}
diff --git a/node_modules/fast-check/lib/esm/check/arbitrary/definition/Value.js b/node_modules/fast-check/lib/esm/check/arbitrary/definition/Value.js
new file mode 100644
index 0000000000000000000000000000000000000000..347fd39af8c8b12d7a629786577003b8a3a0c451
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/check/arbitrary/definition/Value.js
@@ -0,0 +1,26 @@
+import { cloneMethod, hasCloneMethod } from '../../symbols.js';
+const safeObjectDefineProperty = Object.defineProperty;
+export class Value {
+ constructor(value_, context, customGetValue = undefined) {
+ this.value_ = value_;
+ this.context = context;
+ this.hasToBeCloned = customGetValue !== undefined || hasCloneMethod(value_);
+ this.readOnce = false;
+ if (this.hasToBeCloned) {
+ safeObjectDefineProperty(this, 'value', { get: customGetValue !== undefined ? customGetValue : this.getValue });
+ }
+ else {
+ this.value = value_;
+ }
+ }
+ getValue() {
+ if (this.hasToBeCloned) {
+ if (!this.readOnce) {
+ this.readOnce = true;
+ return this.value_;
+ }
+ return this.value_[cloneMethod]();
+ }
+ return this.value_;
+ }
+}
diff --git a/node_modules/fast-check/lib/esm/check/model/ModelRunner.js b/node_modules/fast-check/lib/esm/check/model/ModelRunner.js
new file mode 100644
index 0000000000000000000000000000000000000000..eea94265a4cb9e6724165a4bd4c6ff7d63b0bde5
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/check/model/ModelRunner.js
@@ -0,0 +1,60 @@
+import { scheduleCommands } from './commands/ScheduledCommand.js';
+const genericModelRun = (s, cmds, initialValue, runCmd, then) => {
+ return s.then((o) => {
+ const { model, real } = o;
+ let state = initialValue;
+ for (const c of cmds) {
+ state = then(state, () => {
+ return runCmd(c, model, real);
+ });
+ }
+ return state;
+ });
+};
+const internalModelRun = (s, cmds) => {
+ const then = (_p, c) => c();
+ const setupProducer = {
+ then: (fun) => {
+ fun(s());
+ return undefined;
+ },
+ };
+ const runSync = (cmd, m, r) => {
+ if (cmd.check(m))
+ cmd.run(m, r);
+ return undefined;
+ };
+ return genericModelRun(setupProducer, cmds, undefined, runSync, then);
+};
+const isAsyncSetup = (s) => {
+ return typeof s.then === 'function';
+};
+const internalAsyncModelRun = async (s, cmds, defaultPromise = Promise.resolve()) => {
+ const then = (p, c) => p.then(c);
+ const setupProducer = {
+ then: (fun) => {
+ const out = s();
+ if (isAsyncSetup(out))
+ return out.then(fun);
+ else
+ return fun(out);
+ },
+ };
+ const runAsync = async (cmd, m, r) => {
+ if (await cmd.check(m))
+ await cmd.run(m, r);
+ };
+ return await genericModelRun(setupProducer, cmds, defaultPromise, runAsync, then);
+};
+export function modelRun(s, cmds) {
+ internalModelRun(s, cmds);
+}
+export async function asyncModelRun(s, cmds) {
+ await internalAsyncModelRun(s, cmds);
+}
+export async function scheduledModelRun(scheduler, s, cmds) {
+ const scheduledCommands = scheduleCommands(scheduler, cmds);
+ const out = internalAsyncModelRun(s, scheduledCommands, scheduler.schedule(Promise.resolve(), 'startModel'));
+ await scheduler.waitFor(out);
+ await scheduler.waitAll();
+}
diff --git a/node_modules/fast-check/lib/esm/check/model/ReplayPath.js b/node_modules/fast-check/lib/esm/check/model/ReplayPath.js
new file mode 100644
index 0000000000000000000000000000000000000000..192961536062b872fee9719a5a66bf0a202ed1f8
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/check/model/ReplayPath.js
@@ -0,0 +1,78 @@
+export class ReplayPath {
+ static parse(replayPathStr) {
+ const [serializedCount, serializedChanges] = replayPathStr.split(':');
+ const counts = this.parseCounts(serializedCount);
+ const changes = this.parseChanges(serializedChanges);
+ return this.parseOccurences(counts, changes);
+ }
+ static stringify(replayPath) {
+ const occurences = this.countOccurences(replayPath);
+ const serializedCount = this.stringifyCounts(occurences);
+ const serializedChanges = this.stringifyChanges(occurences);
+ return `${serializedCount}:${serializedChanges}`;
+ }
+ static intToB64(n) {
+ if (n < 26)
+ return String.fromCharCode(n + 65);
+ if (n < 52)
+ return String.fromCharCode(n + 97 - 26);
+ if (n < 62)
+ return String.fromCharCode(n + 48 - 52);
+ return String.fromCharCode(n === 62 ? 43 : 47);
+ }
+ static b64ToInt(c) {
+ if (c >= 'a')
+ return c.charCodeAt(0) - 97 + 26;
+ if (c >= 'A')
+ return c.charCodeAt(0) - 65;
+ if (c >= '0')
+ return c.charCodeAt(0) - 48 + 52;
+ return c === '+' ? 62 : 63;
+ }
+ static countOccurences(replayPath) {
+ return replayPath.reduce((counts, cur) => {
+ if (counts.length === 0 || counts[counts.length - 1].count === 64 || counts[counts.length - 1].value !== cur)
+ counts.push({ value: cur, count: 1 });
+ else
+ counts[counts.length - 1].count += 1;
+ return counts;
+ }, []);
+ }
+ static parseOccurences(counts, changes) {
+ const replayPath = [];
+ for (let idx = 0; idx !== counts.length; ++idx) {
+ const count = counts[idx];
+ const value = changes[idx];
+ for (let num = 0; num !== count; ++num)
+ replayPath.push(value);
+ }
+ return replayPath;
+ }
+ static stringifyChanges(occurences) {
+ let serializedChanges = '';
+ for (let idx = 0; idx < occurences.length; idx += 6) {
+ const changesInt = occurences
+ .slice(idx, idx + 6)
+ .reduceRight((prev, cur) => prev * 2 + (cur.value ? 1 : 0), 0);
+ serializedChanges += this.intToB64(changesInt);
+ }
+ return serializedChanges;
+ }
+ static parseChanges(serializedChanges) {
+ const changesInt = serializedChanges.split('').map((c) => this.b64ToInt(c));
+ const changes = [];
+ for (let idx = 0; idx !== changesInt.length; ++idx) {
+ let current = changesInt[idx];
+ for (let n = 0; n !== 6; ++n, current >>= 1) {
+ changes.push(current % 2 === 1);
+ }
+ }
+ return changes;
+ }
+ static stringifyCounts(occurences) {
+ return occurences.map(({ count }) => this.intToB64(count - 1)).join('');
+ }
+ static parseCounts(serializedCount) {
+ return serializedCount.split('').map((c) => this.b64ToInt(c) + 1);
+ }
+}
diff --git a/node_modules/fast-check/lib/esm/check/model/command/AsyncCommand.js b/node_modules/fast-check/lib/esm/check/model/command/AsyncCommand.js
new file mode 100644
index 0000000000000000000000000000000000000000..cb0ff5c3b541f646105198ee23ac0fc3d805023e
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/check/model/command/AsyncCommand.js
@@ -0,0 +1 @@
+export {};
diff --git a/node_modules/fast-check/lib/esm/check/model/command/Command.js b/node_modules/fast-check/lib/esm/check/model/command/Command.js
new file mode 100644
index 0000000000000000000000000000000000000000..cb0ff5c3b541f646105198ee23ac0fc3d805023e
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/check/model/command/Command.js
@@ -0,0 +1 @@
+export {};
diff --git a/node_modules/fast-check/lib/esm/check/model/command/ICommand.js b/node_modules/fast-check/lib/esm/check/model/command/ICommand.js
new file mode 100644
index 0000000000000000000000000000000000000000..cb0ff5c3b541f646105198ee23ac0fc3d805023e
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/check/model/command/ICommand.js
@@ -0,0 +1 @@
+export {};
diff --git a/node_modules/fast-check/lib/esm/check/model/commands/CommandWrapper.js b/node_modules/fast-check/lib/esm/check/model/commands/CommandWrapper.js
new file mode 100644
index 0000000000000000000000000000000000000000..212728517b1ec8ca546d43e358289d99d073dcb3
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/check/model/commands/CommandWrapper.js
@@ -0,0 +1,35 @@
+import { asyncToStringMethod, hasAsyncToStringMethod, hasToStringMethod, toStringMethod, } from '../../../utils/stringify.js';
+import { cloneMethod, hasCloneMethod } from '../../symbols.js';
+export class CommandWrapper {
+ constructor(cmd) {
+ this.cmd = cmd;
+ this.hasRan = false;
+ if (hasToStringMethod(cmd)) {
+ const method = cmd[toStringMethod];
+ this[toStringMethod] = function toStringMethod() {
+ return method.call(cmd);
+ };
+ }
+ if (hasAsyncToStringMethod(cmd)) {
+ const method = cmd[asyncToStringMethod];
+ this[asyncToStringMethod] = function asyncToStringMethod() {
+ return method.call(cmd);
+ };
+ }
+ }
+ check(m) {
+ return this.cmd.check(m);
+ }
+ run(m, r) {
+ this.hasRan = true;
+ return this.cmd.run(m, r);
+ }
+ clone() {
+ if (hasCloneMethod(this.cmd))
+ return new CommandWrapper(this.cmd[cloneMethod]());
+ return new CommandWrapper(this.cmd);
+ }
+ toString() {
+ return this.cmd.toString();
+ }
+}
diff --git a/node_modules/fast-check/lib/esm/check/model/commands/CommandsContraints.js b/node_modules/fast-check/lib/esm/check/model/commands/CommandsContraints.js
new file mode 100644
index 0000000000000000000000000000000000000000..cb0ff5c3b541f646105198ee23ac0fc3d805023e
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/check/model/commands/CommandsContraints.js
@@ -0,0 +1 @@
+export {};
diff --git a/node_modules/fast-check/lib/esm/check/model/commands/CommandsIterable.js b/node_modules/fast-check/lib/esm/check/model/commands/CommandsIterable.js
new file mode 100644
index 0000000000000000000000000000000000000000..91b251641e272c2bd99e63474b823f6c69464604
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/check/model/commands/CommandsIterable.js
@@ -0,0 +1,21 @@
+import { cloneMethod } from '../../symbols.js';
+export class CommandsIterable {
+ constructor(commands, metadataForReplay) {
+ this.commands = commands;
+ this.metadataForReplay = metadataForReplay;
+ }
+ [Symbol.iterator]() {
+ return this.commands[Symbol.iterator]();
+ }
+ [cloneMethod]() {
+ return new CommandsIterable(this.commands.map((c) => c.clone()), this.metadataForReplay);
+ }
+ toString() {
+ const serializedCommands = this.commands
+ .filter((c) => c.hasRan)
+ .map((c) => c.toString())
+ .join(',');
+ const metadata = this.metadataForReplay();
+ return metadata.length !== 0 ? `${serializedCommands} /*${metadata}*/` : serializedCommands;
+ }
+}
diff --git a/node_modules/fast-check/lib/esm/check/model/commands/ScheduledCommand.js b/node_modules/fast-check/lib/esm/check/model/commands/ScheduledCommand.js
new file mode 100644
index 0000000000000000000000000000000000000000..9f9005bd0873a77810d89903b9a212cad3866381
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/check/model/commands/ScheduledCommand.js
@@ -0,0 +1,53 @@
+export class ScheduledCommand {
+ constructor(s, cmd) {
+ this.s = s;
+ this.cmd = cmd;
+ }
+ async check(m) {
+ let error = null;
+ let checkPassed = false;
+ const status = await this.s.scheduleSequence([
+ {
+ label: `check@${this.cmd.toString()}`,
+ builder: async () => {
+ try {
+ checkPassed = await Promise.resolve(this.cmd.check(m));
+ }
+ catch (err) {
+ error = err;
+ throw err;
+ }
+ },
+ },
+ ]).task;
+ if (status.faulty) {
+ throw error;
+ }
+ return checkPassed;
+ }
+ async run(m, r) {
+ let error = null;
+ const status = await this.s.scheduleSequence([
+ {
+ label: `run@${this.cmd.toString()}`,
+ builder: async () => {
+ try {
+ await this.cmd.run(m, r);
+ }
+ catch (err) {
+ error = err;
+ throw err;
+ }
+ },
+ },
+ ]).task;
+ if (status.faulty) {
+ throw error;
+ }
+ }
+}
+export const scheduleCommands = function* (s, cmds) {
+ for (const cmd of cmds) {
+ yield new ScheduledCommand(s, cmd);
+ }
+};
diff --git a/node_modules/fast-check/lib/esm/check/precondition/Pre.js b/node_modules/fast-check/lib/esm/check/precondition/Pre.js
new file mode 100644
index 0000000000000000000000000000000000000000..669ca5e587aa07896dba13c038938c7011307de8
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/check/precondition/Pre.js
@@ -0,0 +1,6 @@
+import { PreconditionFailure } from './PreconditionFailure.js';
+export function pre(expectTruthy) {
+ if (!expectTruthy) {
+ throw new PreconditionFailure();
+ }
+}
diff --git a/node_modules/fast-check/lib/esm/check/precondition/PreconditionFailure.js b/node_modules/fast-check/lib/esm/check/precondition/PreconditionFailure.js
new file mode 100644
index 0000000000000000000000000000000000000000..eba5a0b836fc095fe4d50dd33d2e3c7a5d8ddd92
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/check/precondition/PreconditionFailure.js
@@ -0,0 +1,11 @@
+export class PreconditionFailure extends Error {
+ constructor(interruptExecution = false) {
+ super();
+ this.interruptExecution = interruptExecution;
+ this.footprint = PreconditionFailure.SharedFootPrint;
+ }
+ static isFailure(err) {
+ return err != null && err.footprint === PreconditionFailure.SharedFootPrint;
+ }
+}
+PreconditionFailure.SharedFootPrint = Symbol.for('fast-check/PreconditionFailure');
diff --git a/node_modules/fast-check/lib/esm/check/property/AsyncProperty.generic.js b/node_modules/fast-check/lib/esm/check/property/AsyncProperty.generic.js
new file mode 100644
index 0000000000000000000000000000000000000000..ba8b18af9798072b633d893f41394e20cb1676e6
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/check/property/AsyncProperty.generic.js
@@ -0,0 +1,79 @@
+import { PreconditionFailure } from '../precondition/PreconditionFailure.js';
+import { runIdToFrequency } from './IRawProperty.js';
+import { readConfigureGlobal } from '../runner/configuration/GlobalParameters.js';
+import { Stream } from '../../stream/Stream.js';
+import { noUndefinedAsContext, UndefinedContextPlaceholder, } from '../../arbitrary/_internals/helpers/NoUndefinedAsContext.js';
+import { Error, String } from '../../utils/globals.js';
+export class AsyncProperty {
+ constructor(arb, predicate) {
+ this.arb = arb;
+ this.predicate = predicate;
+ const { asyncBeforeEach, asyncAfterEach, beforeEach, afterEach } = readConfigureGlobal() || {};
+ if (asyncBeforeEach !== undefined && beforeEach !== undefined) {
+ throw Error('Global "asyncBeforeEach" and "beforeEach" parameters can\'t be set at the same time when running async properties');
+ }
+ if (asyncAfterEach !== undefined && afterEach !== undefined) {
+ throw Error('Global "asyncAfterEach" and "afterEach" parameters can\'t be set at the same time when running async properties');
+ }
+ this.beforeEachHook = asyncBeforeEach || beforeEach || AsyncProperty.dummyHook;
+ this.afterEachHook = asyncAfterEach || afterEach || AsyncProperty.dummyHook;
+ }
+ isAsync() {
+ return true;
+ }
+ generate(mrng, runId) {
+ const value = this.arb.generate(mrng, runId != null ? runIdToFrequency(runId) : undefined);
+ return noUndefinedAsContext(value);
+ }
+ shrink(value) {
+ if (value.context === undefined && !this.arb.canShrinkWithoutContext(value.value_)) {
+ return Stream.nil();
+ }
+ const safeContext = value.context !== UndefinedContextPlaceholder ? value.context : undefined;
+ return this.arb.shrink(value.value_, safeContext).map(noUndefinedAsContext);
+ }
+ async runBeforeEach() {
+ await this.beforeEachHook();
+ }
+ async runAfterEach() {
+ await this.afterEachHook();
+ }
+ async run(v, dontRunHook) {
+ if (!dontRunHook) {
+ await this.beforeEachHook();
+ }
+ try {
+ const output = await this.predicate(v);
+ return output == null || output === true
+ ? null
+ : {
+ error: new Error('Property failed by returning false'),
+ errorMessage: 'Error: Property failed by returning false',
+ };
+ }
+ catch (err) {
+ if (PreconditionFailure.isFailure(err))
+ return err;
+ if (err instanceof Error && err.stack) {
+ return { error: err, errorMessage: err.stack };
+ }
+ return { error: err, errorMessage: String(err) };
+ }
+ finally {
+ if (!dontRunHook) {
+ await this.afterEachHook();
+ }
+ }
+ }
+ beforeEach(hookFunction) {
+ const previousBeforeEachHook = this.beforeEachHook;
+ this.beforeEachHook = () => hookFunction(previousBeforeEachHook);
+ return this;
+ }
+ afterEach(hookFunction) {
+ const previousAfterEachHook = this.afterEachHook;
+ this.afterEachHook = () => hookFunction(previousAfterEachHook);
+ return this;
+ }
+}
+AsyncProperty.dummyHook = () => { };
diff --git a/node_modules/fast-check/lib/esm/check/property/AsyncProperty.js b/node_modules/fast-check/lib/esm/check/property/AsyncProperty.js
new file mode 100644
index 0000000000000000000000000000000000000000..23a09fef7d5c4199d3e5e1a5008b96fbab33a4b0
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/check/property/AsyncProperty.js
@@ -0,0 +1,16 @@
+import { assertIsArbitrary } from '../arbitrary/definition/Arbitrary.js';
+import { tuple } from '../../arbitrary/tuple.js';
+import { AsyncProperty } from './AsyncProperty.generic.js';
+import { AlwaysShrinkableArbitrary } from '../../arbitrary/_internals/AlwaysShrinkableArbitrary.js';
+import { safeForEach, safeMap, safeSlice } from '../../utils/globals.js';
+function asyncProperty(...args) {
+ if (args.length < 2) {
+ throw new Error('asyncProperty expects at least two parameters');
+ }
+ const arbs = safeSlice(args, 0, args.length - 1);
+ const p = args[args.length - 1];
+ safeForEach(arbs, assertIsArbitrary);
+ const mappedArbs = safeMap(arbs, (arb) => new AlwaysShrinkableArbitrary(arb));
+ return new AsyncProperty(tuple(...mappedArbs), (t) => p(...t));
+}
+export { asyncProperty };
diff --git a/node_modules/fast-check/lib/esm/check/property/IRawProperty.js b/node_modules/fast-check/lib/esm/check/property/IRawProperty.js
new file mode 100644
index 0000000000000000000000000000000000000000..9e3086f5bb961017d9f69774ecce4d760049b1ec
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/check/property/IRawProperty.js
@@ -0,0 +1,4 @@
+const safeMathLog = Math.log;
+export function runIdToFrequency(runId) {
+ return 2 + ~~(safeMathLog(runId + 1) * 0.4342944819032518);
+}
diff --git a/node_modules/fast-check/lib/esm/check/property/IgnoreEqualValuesProperty.js b/node_modules/fast-check/lib/esm/check/property/IgnoreEqualValuesProperty.js
new file mode 100644
index 0000000000000000000000000000000000000000..bc5e8addb193b6f9c3fcf914ecd6fc27b3ced522
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/check/property/IgnoreEqualValuesProperty.js
@@ -0,0 +1,46 @@
+import { stringify } from '../../utils/stringify.js';
+import { PreconditionFailure } from '../precondition/PreconditionFailure.js';
+function fromSyncCached(cachedValue) {
+ return cachedValue === null ? new PreconditionFailure() : cachedValue;
+}
+function fromCached(...data) {
+ if (data[1])
+ return data[0].then(fromSyncCached);
+ return fromSyncCached(data[0]);
+}
+function fromCachedUnsafe(cachedValue, isAsync) {
+ return fromCached(cachedValue, isAsync);
+}
+export class IgnoreEqualValuesProperty {
+ constructor(property, skipRuns) {
+ this.property = property;
+ this.skipRuns = skipRuns;
+ this.coveredCases = new Map();
+ if (this.property.runBeforeEach !== undefined && this.property.runAfterEach !== undefined) {
+ this.runBeforeEach = () => this.property.runBeforeEach();
+ this.runAfterEach = () => this.property.runAfterEach();
+ }
+ }
+ isAsync() {
+ return this.property.isAsync();
+ }
+ generate(mrng, runId) {
+ return this.property.generate(mrng, runId);
+ }
+ shrink(value) {
+ return this.property.shrink(value);
+ }
+ run(v, dontRunHook) {
+ const stringifiedValue = stringify(v);
+ if (this.coveredCases.has(stringifiedValue)) {
+ const lastOutput = this.coveredCases.get(stringifiedValue);
+ if (!this.skipRuns) {
+ return lastOutput;
+ }
+ return fromCachedUnsafe(lastOutput, this.property.isAsync());
+ }
+ const out = this.property.run(v, dontRunHook);
+ this.coveredCases.set(stringifiedValue, out);
+ return out;
+ }
+}
diff --git a/node_modules/fast-check/lib/esm/check/property/Property.generic.js b/node_modules/fast-check/lib/esm/check/property/Property.generic.js
new file mode 100644
index 0000000000000000000000000000000000000000..4b1bf3f968b1b6d24da9f0d002bafda31d83715b
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/check/property/Property.generic.js
@@ -0,0 +1,79 @@
+import { PreconditionFailure } from '../precondition/PreconditionFailure.js';
+import { runIdToFrequency } from './IRawProperty.js';
+import { readConfigureGlobal } from '../runner/configuration/GlobalParameters.js';
+import { Stream } from '../../stream/Stream.js';
+import { noUndefinedAsContext, UndefinedContextPlaceholder, } from '../../arbitrary/_internals/helpers/NoUndefinedAsContext.js';
+import { Error, String } from '../../utils/globals.js';
+export class Property {
+ constructor(arb, predicate) {
+ this.arb = arb;
+ this.predicate = predicate;
+ const { beforeEach = Property.dummyHook, afterEach = Property.dummyHook, asyncBeforeEach, asyncAfterEach, } = readConfigureGlobal() || {};
+ if (asyncBeforeEach !== undefined) {
+ throw Error('"asyncBeforeEach" can\'t be set when running synchronous properties');
+ }
+ if (asyncAfterEach !== undefined) {
+ throw Error('"asyncAfterEach" can\'t be set when running synchronous properties');
+ }
+ this.beforeEachHook = beforeEach;
+ this.afterEachHook = afterEach;
+ }
+ isAsync() {
+ return false;
+ }
+ generate(mrng, runId) {
+ const value = this.arb.generate(mrng, runId != null ? runIdToFrequency(runId) : undefined);
+ return noUndefinedAsContext(value);
+ }
+ shrink(value) {
+ if (value.context === undefined && !this.arb.canShrinkWithoutContext(value.value_)) {
+ return Stream.nil();
+ }
+ const safeContext = value.context !== UndefinedContextPlaceholder ? value.context : undefined;
+ return this.arb.shrink(value.value_, safeContext).map(noUndefinedAsContext);
+ }
+ runBeforeEach() {
+ this.beforeEachHook();
+ }
+ runAfterEach() {
+ this.afterEachHook();
+ }
+ run(v, dontRunHook) {
+ if (!dontRunHook) {
+ this.beforeEachHook();
+ }
+ try {
+ const output = this.predicate(v);
+ return output == null || output === true
+ ? null
+ : {
+ error: new Error('Property failed by returning false'),
+ errorMessage: 'Error: Property failed by returning false',
+ };
+ }
+ catch (err) {
+ if (PreconditionFailure.isFailure(err))
+ return err;
+ if (err instanceof Error && err.stack) {
+ return { error: err, errorMessage: err.stack };
+ }
+ return { error: err, errorMessage: String(err) };
+ }
+ finally {
+ if (!dontRunHook) {
+ this.afterEachHook();
+ }
+ }
+ }
+ beforeEach(hookFunction) {
+ const previousBeforeEachHook = this.beforeEachHook;
+ this.beforeEachHook = () => hookFunction(previousBeforeEachHook);
+ return this;
+ }
+ afterEach(hookFunction) {
+ const previousAfterEachHook = this.afterEachHook;
+ this.afterEachHook = () => hookFunction(previousAfterEachHook);
+ return this;
+ }
+}
+Property.dummyHook = () => { };
diff --git a/node_modules/fast-check/lib/esm/check/property/Property.js b/node_modules/fast-check/lib/esm/check/property/Property.js
new file mode 100644
index 0000000000000000000000000000000000000000..227fb1cce283894cdc0e6946753304a70eff3091
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/check/property/Property.js
@@ -0,0 +1,16 @@
+import { assertIsArbitrary } from '../arbitrary/definition/Arbitrary.js';
+import { tuple } from '../../arbitrary/tuple.js';
+import { Property } from './Property.generic.js';
+import { AlwaysShrinkableArbitrary } from '../../arbitrary/_internals/AlwaysShrinkableArbitrary.js';
+import { safeForEach, safeMap, safeSlice } from '../../utils/globals.js';
+function property(...args) {
+ if (args.length < 2) {
+ throw new Error('property expects at least two parameters');
+ }
+ const arbs = safeSlice(args, 0, args.length - 1);
+ const p = args[args.length - 1];
+ safeForEach(arbs, assertIsArbitrary);
+ const mappedArbs = safeMap(arbs, (arb) => new AlwaysShrinkableArbitrary(arb));
+ return new Property(tuple(...mappedArbs), (t) => p(...t));
+}
+export { property };
diff --git a/node_modules/fast-check/lib/esm/check/property/SkipAfterProperty.js b/node_modules/fast-check/lib/esm/check/property/SkipAfterProperty.js
new file mode 100644
index 0000000000000000000000000000000000000000..930d7acba7e66cff651ba8554be19b8549251b73
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/check/property/SkipAfterProperty.js
@@ -0,0 +1,56 @@
+import { PreconditionFailure } from '../precondition/PreconditionFailure.js';
+function interruptAfter(timeMs, setTimeoutSafe, clearTimeoutSafe) {
+ let timeoutHandle = null;
+ const promise = new Promise((resolve) => {
+ timeoutHandle = setTimeoutSafe(() => {
+ const preconditionFailure = new PreconditionFailure(true);
+ resolve(preconditionFailure);
+ }, timeMs);
+ });
+ return {
+ clear: () => clearTimeoutSafe(timeoutHandle),
+ promise,
+ };
+}
+export class SkipAfterProperty {
+ constructor(property, getTime, timeLimit, interruptExecution, setTimeoutSafe, clearTimeoutSafe) {
+ this.property = property;
+ this.getTime = getTime;
+ this.interruptExecution = interruptExecution;
+ this.setTimeoutSafe = setTimeoutSafe;
+ this.clearTimeoutSafe = clearTimeoutSafe;
+ this.skipAfterTime = this.getTime() + timeLimit;
+ if (this.property.runBeforeEach !== undefined && this.property.runAfterEach !== undefined) {
+ this.runBeforeEach = () => this.property.runBeforeEach();
+ this.runAfterEach = () => this.property.runAfterEach();
+ }
+ }
+ isAsync() {
+ return this.property.isAsync();
+ }
+ generate(mrng, runId) {
+ return this.property.generate(mrng, runId);
+ }
+ shrink(value) {
+ return this.property.shrink(value);
+ }
+ run(v, dontRunHook) {
+ const remainingTime = this.skipAfterTime - this.getTime();
+ if (remainingTime <= 0) {
+ const preconditionFailure = new PreconditionFailure(this.interruptExecution);
+ if (this.isAsync()) {
+ return Promise.resolve(preconditionFailure);
+ }
+ else {
+ return preconditionFailure;
+ }
+ }
+ if (this.interruptExecution && this.isAsync()) {
+ const t = interruptAfter(remainingTime, this.setTimeoutSafe, this.clearTimeoutSafe);
+ const propRun = Promise.race([this.property.run(v, dontRunHook), t.promise]);
+ propRun.then(t.clear, t.clear);
+ return propRun;
+ }
+ return this.property.run(v, dontRunHook);
+ }
+}
diff --git a/node_modules/fast-check/lib/esm/check/property/TimeoutProperty.js b/node_modules/fast-check/lib/esm/check/property/TimeoutProperty.js
new file mode 100644
index 0000000000000000000000000000000000000000..1020af7495fc359ef427b502cf576db5a4dc54f5
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/check/property/TimeoutProperty.js
@@ -0,0 +1,43 @@
+import { Error } from '../../utils/globals.js';
+const timeoutAfter = (timeMs, setTimeoutSafe, clearTimeoutSafe) => {
+ let timeoutHandle = null;
+ const promise = new Promise((resolve) => {
+ timeoutHandle = setTimeoutSafe(() => {
+ resolve({
+ error: new Error(`Property timeout: exceeded limit of ${timeMs} milliseconds`),
+ errorMessage: `Property timeout: exceeded limit of ${timeMs} milliseconds`,
+ });
+ }, timeMs);
+ });
+ return {
+ clear: () => clearTimeoutSafe(timeoutHandle),
+ promise,
+ };
+};
+export class TimeoutProperty {
+ constructor(property, timeMs, setTimeoutSafe, clearTimeoutSafe) {
+ this.property = property;
+ this.timeMs = timeMs;
+ this.setTimeoutSafe = setTimeoutSafe;
+ this.clearTimeoutSafe = clearTimeoutSafe;
+ if (this.property.runBeforeEach !== undefined && this.property.runAfterEach !== undefined) {
+ this.runBeforeEach = () => Promise.resolve(this.property.runBeforeEach());
+ this.runAfterEach = () => Promise.resolve(this.property.runAfterEach());
+ }
+ }
+ isAsync() {
+ return true;
+ }
+ generate(mrng, runId) {
+ return this.property.generate(mrng, runId);
+ }
+ shrink(value) {
+ return this.property.shrink(value);
+ }
+ async run(v, dontRunHook) {
+ const t = timeoutAfter(this.timeMs, this.setTimeoutSafe, this.clearTimeoutSafe);
+ const propRun = Promise.race([this.property.run(v, dontRunHook), t.promise]);
+ propRun.then(t.clear, t.clear);
+ return propRun;
+ }
+}
diff --git a/node_modules/fast-check/lib/esm/check/property/UnbiasedProperty.js b/node_modules/fast-check/lib/esm/check/property/UnbiasedProperty.js
new file mode 100644
index 0000000000000000000000000000000000000000..73f570bfe0f0735e9b9b3b41608159cd43f9aa70
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/check/property/UnbiasedProperty.js
@@ -0,0 +1,21 @@
+export class UnbiasedProperty {
+ constructor(property) {
+ this.property = property;
+ if (this.property.runBeforeEach !== undefined && this.property.runAfterEach !== undefined) {
+ this.runBeforeEach = () => this.property.runBeforeEach();
+ this.runAfterEach = () => this.property.runAfterEach();
+ }
+ }
+ isAsync() {
+ return this.property.isAsync();
+ }
+ generate(mrng, _runId) {
+ return this.property.generate(mrng, undefined);
+ }
+ shrink(value) {
+ return this.property.shrink(value);
+ }
+ run(v, dontRunHook) {
+ return this.property.run(v, dontRunHook);
+ }
+}
diff --git a/node_modules/fast-check/lib/esm/check/runner/DecorateProperty.js b/node_modules/fast-check/lib/esm/check/runner/DecorateProperty.js
new file mode 100644
index 0000000000000000000000000000000000000000..21fcd9de2cff7eb2679bd3210adb234ca7d0c279
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/check/runner/DecorateProperty.js
@@ -0,0 +1,29 @@
+import { SkipAfterProperty } from '../property/SkipAfterProperty.js';
+import { TimeoutProperty } from '../property/TimeoutProperty.js';
+import { UnbiasedProperty } from '../property/UnbiasedProperty.js';
+import { IgnoreEqualValuesProperty } from '../property/IgnoreEqualValuesProperty.js';
+const safeDateNow = Date.now;
+const safeSetTimeout = setTimeout;
+const safeClearTimeout = clearTimeout;
+export function decorateProperty(rawProperty, qParams) {
+ let prop = rawProperty;
+ if (rawProperty.isAsync() && qParams.timeout != null) {
+ prop = new TimeoutProperty(prop, qParams.timeout, safeSetTimeout, safeClearTimeout);
+ }
+ if (qParams.unbiased) {
+ prop = new UnbiasedProperty(prop);
+ }
+ if (qParams.skipAllAfterTimeLimit != null) {
+ prop = new SkipAfterProperty(prop, safeDateNow, qParams.skipAllAfterTimeLimit, false, safeSetTimeout, safeClearTimeout);
+ }
+ if (qParams.interruptAfterTimeLimit != null) {
+ prop = new SkipAfterProperty(prop, safeDateNow, qParams.interruptAfterTimeLimit, true, safeSetTimeout, safeClearTimeout);
+ }
+ if (qParams.skipEqualValues) {
+ prop = new IgnoreEqualValuesProperty(prop, true);
+ }
+ if (qParams.ignoreEqualValues) {
+ prop = new IgnoreEqualValuesProperty(prop, false);
+ }
+ return prop;
+}
diff --git a/node_modules/fast-check/lib/esm/check/runner/Runner.js b/node_modules/fast-check/lib/esm/check/runner/Runner.js
new file mode 100644
index 0000000000000000000000000000000000000000..d39386e13f20843e5d54a4b39809026329131f18
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/check/runner/Runner.js
@@ -0,0 +1,71 @@
+import { Stream, stream } from '../../stream/Stream.js';
+import { readConfigureGlobal } from './configuration/GlobalParameters.js';
+import { QualifiedParameters } from './configuration/QualifiedParameters.js';
+import { decorateProperty } from './DecorateProperty.js';
+import { RunnerIterator } from './RunnerIterator.js';
+import { SourceValuesIterator } from './SourceValuesIterator.js';
+import { lazyToss, toss } from './Tosser.js';
+import { pathWalk } from './utils/PathWalker.js';
+import { asyncReportRunDetails, reportRunDetails } from './utils/RunDetailsFormatter.js';
+const safeObjectAssign = Object.assign;
+function runIt(property, shrink, sourceValues, verbose, interruptedAsFailure) {
+ const isModernProperty = property.runBeforeEach !== undefined && property.runAfterEach !== undefined;
+ const runner = new RunnerIterator(sourceValues, shrink, verbose, interruptedAsFailure);
+ for (const v of runner) {
+ if (isModernProperty) {
+ property.runBeforeEach();
+ }
+ const out = property.run(v, isModernProperty);
+ if (isModernProperty) {
+ property.runAfterEach();
+ }
+ runner.handleResult(out);
+ }
+ return runner.runExecution;
+}
+async function asyncRunIt(property, shrink, sourceValues, verbose, interruptedAsFailure) {
+ const isModernProperty = property.runBeforeEach !== undefined && property.runAfterEach !== undefined;
+ const runner = new RunnerIterator(sourceValues, shrink, verbose, interruptedAsFailure);
+ for (const v of runner) {
+ if (isModernProperty) {
+ await property.runBeforeEach();
+ }
+ const out = await property.run(v, isModernProperty);
+ if (isModernProperty) {
+ await property.runAfterEach();
+ }
+ runner.handleResult(out);
+ }
+ return runner.runExecution;
+}
+function check(rawProperty, params) {
+ if (rawProperty == null || rawProperty.generate == null)
+ throw new Error('Invalid property encountered, please use a valid property');
+ if (rawProperty.run == null)
+ throw new Error('Invalid property encountered, please use a valid property not an arbitrary');
+ const qParams = QualifiedParameters.read(safeObjectAssign(safeObjectAssign({}, readConfigureGlobal()), params));
+ if (qParams.reporter !== null && qParams.asyncReporter !== null)
+ throw new Error('Invalid parameters encountered, reporter and asyncReporter cannot be specified together');
+ if (qParams.asyncReporter !== null && !rawProperty.isAsync())
+ throw new Error('Invalid parameters encountered, only asyncProperty can be used when asyncReporter specified');
+ const property = decorateProperty(rawProperty, qParams);
+ const maxInitialIterations = qParams.path.length === 0 || qParams.path.indexOf(':') === -1 ? qParams.numRuns : -1;
+ const maxSkips = qParams.numRuns * qParams.maxSkipsPerRun;
+ const shrink = (...args) => property.shrink(...args);
+ const initialValues = qParams.path.length === 0
+ ? toss(property, qParams.seed, qParams.randomType, qParams.examples)
+ : pathWalk(qParams.path, stream(lazyToss(property, qParams.seed, qParams.randomType, qParams.examples)), shrink);
+ const sourceValues = new SourceValuesIterator(initialValues, maxInitialIterations, maxSkips);
+ const finalShrink = !qParams.endOnFailure ? shrink : Stream.nil;
+ return property.isAsync()
+ ? asyncRunIt(property, finalShrink, sourceValues, qParams.verbose, qParams.markInterruptAsFailure).then((e) => e.toRunDetails(qParams.seed, qParams.path, maxSkips, qParams))
+ : runIt(property, finalShrink, sourceValues, qParams.verbose, qParams.markInterruptAsFailure).toRunDetails(qParams.seed, qParams.path, maxSkips, qParams);
+}
+function assert(property, params) {
+ const out = check(property, params);
+ if (property.isAsync())
+ return out.then(asyncReportRunDetails);
+ else
+ reportRunDetails(out);
+}
+export { check, assert };
diff --git a/node_modules/fast-check/lib/esm/check/runner/RunnerIterator.js b/node_modules/fast-check/lib/esm/check/runner/RunnerIterator.js
new file mode 100644
index 0000000000000000000000000000000000000000..7ccb9d56f0e1ab0991bb6a6ad34cf3a4875a8643
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/check/runner/RunnerIterator.js
@@ -0,0 +1,42 @@
+import { PreconditionFailure } from '../precondition/PreconditionFailure.js';
+import { RunExecution } from './reporter/RunExecution.js';
+export class RunnerIterator {
+ constructor(sourceValues, shrink, verbose, interruptedAsFailure) {
+ this.sourceValues = sourceValues;
+ this.shrink = shrink;
+ this.runExecution = new RunExecution(verbose, interruptedAsFailure);
+ this.currentIdx = -1;
+ this.nextValues = sourceValues;
+ }
+ [Symbol.iterator]() {
+ return this;
+ }
+ next() {
+ const nextValue = this.nextValues.next();
+ if (nextValue.done || this.runExecution.interrupted) {
+ return { done: true, value: undefined };
+ }
+ this.currentValue = nextValue.value;
+ ++this.currentIdx;
+ return { done: false, value: nextValue.value.value_ };
+ }
+ handleResult(result) {
+ if (result != null && typeof result === 'object' && !PreconditionFailure.isFailure(result)) {
+ this.runExecution.fail(this.currentValue.value_, this.currentIdx, result);
+ this.currentIdx = -1;
+ this.nextValues = this.shrink(this.currentValue);
+ }
+ else if (result != null) {
+ if (!result.interruptExecution) {
+ this.runExecution.skip(this.currentValue.value_);
+ this.sourceValues.skippedOne();
+ }
+ else {
+ this.runExecution.interrupt();
+ }
+ }
+ else {
+ this.runExecution.success(this.currentValue.value_);
+ }
+ }
+}
diff --git a/node_modules/fast-check/lib/esm/check/runner/Sampler.js b/node_modules/fast-check/lib/esm/check/runner/Sampler.js
new file mode 100644
index 0000000000000000000000000000000000000000..8600152fa01fc44585d92cfaa63f3c2c91d13b52
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/check/runner/Sampler.js
@@ -0,0 +1,52 @@
+import { stream } from '../../stream/Stream.js';
+import { Property } from '../property/Property.generic.js';
+import { UnbiasedProperty } from '../property/UnbiasedProperty.js';
+import { readConfigureGlobal } from './configuration/GlobalParameters.js';
+import { QualifiedParameters } from './configuration/QualifiedParameters.js';
+import { lazyToss, toss } from './Tosser.js';
+import { pathWalk } from './utils/PathWalker.js';
+function toProperty(generator, qParams) {
+ const prop = !Object.prototype.hasOwnProperty.call(generator, 'isAsync')
+ ? new Property(generator, () => true)
+ : generator;
+ return qParams.unbiased === true ? new UnbiasedProperty(prop) : prop;
+}
+function streamSample(generator, params) {
+ const extendedParams = typeof params === 'number'
+ ? Object.assign(Object.assign({}, readConfigureGlobal()), { numRuns: params }) : Object.assign(Object.assign({}, readConfigureGlobal()), params);
+ const qParams = QualifiedParameters.read(extendedParams);
+ const nextProperty = toProperty(generator, qParams);
+ const shrink = nextProperty.shrink.bind(nextProperty);
+ const tossedValues = qParams.path.length === 0
+ ? stream(toss(nextProperty, qParams.seed, qParams.randomType, qParams.examples))
+ : pathWalk(qParams.path, stream(lazyToss(nextProperty, qParams.seed, qParams.randomType, qParams.examples)), shrink);
+ return tossedValues.take(qParams.numRuns).map((s) => s.value_);
+}
+function sample(generator, params) {
+ return [...streamSample(generator, params)];
+}
+function round2(n) {
+ return (Math.round(n * 100) / 100).toFixed(2);
+}
+function statistics(generator, classify, params) {
+ const extendedParams = typeof params === 'number'
+ ? Object.assign(Object.assign({}, readConfigureGlobal()), { numRuns: params }) : Object.assign(Object.assign({}, readConfigureGlobal()), params);
+ const qParams = QualifiedParameters.read(extendedParams);
+ const recorded = {};
+ for (const g of streamSample(generator, params)) {
+ const out = classify(g);
+ const categories = Array.isArray(out) ? out : [out];
+ for (const c of categories) {
+ recorded[c] = (recorded[c] || 0) + 1;
+ }
+ }
+ const data = Object.entries(recorded)
+ .sort((a, b) => b[1] - a[1])
+ .map((i) => [i[0], `${round2((i[1] * 100.0) / qParams.numRuns)}%`]);
+ const longestName = data.map((i) => i[0].length).reduce((p, c) => Math.max(p, c), 0);
+ const longestPercent = data.map((i) => i[1].length).reduce((p, c) => Math.max(p, c), 0);
+ for (const item of data) {
+ qParams.logger(`${item[0].padEnd(longestName, '.')}..${item[1].padStart(longestPercent, '.')}`);
+ }
+}
+export { sample, statistics };
diff --git a/node_modules/fast-check/lib/esm/check/runner/SourceValuesIterator.js b/node_modules/fast-check/lib/esm/check/runner/SourceValuesIterator.js
new file mode 100644
index 0000000000000000000000000000000000000000..f09e4a757c4a4d3e9ca792ee10eedf345b63aab4
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/check/runner/SourceValuesIterator.js
@@ -0,0 +1,22 @@
+export class SourceValuesIterator {
+ constructor(initialValues, maxInitialIterations, remainingSkips) {
+ this.initialValues = initialValues;
+ this.maxInitialIterations = maxInitialIterations;
+ this.remainingSkips = remainingSkips;
+ }
+ [Symbol.iterator]() {
+ return this;
+ }
+ next() {
+ if (--this.maxInitialIterations !== -1 && this.remainingSkips >= 0) {
+ const n = this.initialValues.next();
+ if (!n.done)
+ return { value: n.value, done: false };
+ }
+ return { value: undefined, done: true };
+ }
+ skippedOne() {
+ --this.remainingSkips;
+ ++this.maxInitialIterations;
+ }
+}
diff --git a/node_modules/fast-check/lib/esm/check/runner/Tosser.js b/node_modules/fast-check/lib/esm/check/runner/Tosser.js
new file mode 100644
index 0000000000000000000000000000000000000000..b5543ad0ed48256d8637066fa3397e8379944769
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/check/runner/Tosser.js
@@ -0,0 +1,28 @@
+import { skipN } from 'pure-rand';
+import { Random } from '../../random/generator/Random.js';
+import { Value } from '../arbitrary/definition/Value.js';
+import { safeMap } from '../../utils/globals.js';
+function tossNext(generator, rng, index) {
+ rng.unsafeJump();
+ return generator.generate(new Random(rng), index);
+}
+export function* toss(generator, seed, random, examples) {
+ for (let idx = 0; idx !== examples.length; ++idx) {
+ yield new Value(examples[idx], undefined);
+ }
+ for (let idx = 0, rng = random(seed);; ++idx) {
+ yield tossNext(generator, rng, idx);
+ }
+}
+function lazyGenerate(generator, rng, idx) {
+ return () => generator.generate(new Random(rng), idx);
+}
+export function* lazyToss(generator, seed, random, examples) {
+ yield* safeMap(examples, (e) => () => new Value(e, undefined));
+ let idx = 0;
+ let rng = random(seed);
+ for (;;) {
+ rng = rng.jump ? rng.jump() : skipN(rng, 42);
+ yield lazyGenerate(generator, rng, idx++);
+ }
+}
diff --git a/node_modules/fast-check/lib/esm/check/runner/configuration/GlobalParameters.js b/node_modules/fast-check/lib/esm/check/runner/configuration/GlobalParameters.js
new file mode 100644
index 0000000000000000000000000000000000000000..211f44c050514ac59ba996c880788a344d8deb92
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/check/runner/configuration/GlobalParameters.js
@@ -0,0 +1,10 @@
+let globalParameters = {};
+export function configureGlobal(parameters) {
+ globalParameters = parameters;
+}
+export function readConfigureGlobal() {
+ return globalParameters;
+}
+export function resetConfigureGlobal() {
+ globalParameters = {};
+}
diff --git a/node_modules/fast-check/lib/esm/check/runner/configuration/Parameters.js b/node_modules/fast-check/lib/esm/check/runner/configuration/Parameters.js
new file mode 100644
index 0000000000000000000000000000000000000000..cb0ff5c3b541f646105198ee23ac0fc3d805023e
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/check/runner/configuration/Parameters.js
@@ -0,0 +1 @@
+export {};
diff --git a/node_modules/fast-check/lib/esm/check/runner/configuration/QualifiedParameters.js b/node_modules/fast-check/lib/esm/check/runner/configuration/QualifiedParameters.js
new file mode 100644
index 0000000000000000000000000000000000000000..8a017ad4249cbd5021a9016ca45d731735724bf3
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/check/runner/configuration/QualifiedParameters.js
@@ -0,0 +1,140 @@
+import prand, { unsafeSkipN } from 'pure-rand';
+import { VerbosityLevel } from './VerbosityLevel.js';
+const safeDateNow = Date.now;
+const safeMathMin = Math.min;
+const safeMathRandom = Math.random;
+export class QualifiedParameters {
+ constructor(op) {
+ const p = op || {};
+ this.seed = QualifiedParameters.readSeed(p);
+ this.randomType = QualifiedParameters.readRandomType(p);
+ this.numRuns = QualifiedParameters.readNumRuns(p);
+ this.verbose = QualifiedParameters.readVerbose(p);
+ this.maxSkipsPerRun = QualifiedParameters.readOrDefault(p, 'maxSkipsPerRun', 100);
+ this.timeout = QualifiedParameters.safeTimeout(QualifiedParameters.readOrDefault(p, 'timeout', null));
+ this.skipAllAfterTimeLimit = QualifiedParameters.safeTimeout(QualifiedParameters.readOrDefault(p, 'skipAllAfterTimeLimit', null));
+ this.interruptAfterTimeLimit = QualifiedParameters.safeTimeout(QualifiedParameters.readOrDefault(p, 'interruptAfterTimeLimit', null));
+ this.markInterruptAsFailure = QualifiedParameters.readBoolean(p, 'markInterruptAsFailure');
+ this.skipEqualValues = QualifiedParameters.readBoolean(p, 'skipEqualValues');
+ this.ignoreEqualValues = QualifiedParameters.readBoolean(p, 'ignoreEqualValues');
+ this.logger = QualifiedParameters.readOrDefault(p, 'logger', (v) => {
+ console.log(v);
+ });
+ this.path = QualifiedParameters.readOrDefault(p, 'path', '');
+ this.unbiased = QualifiedParameters.readBoolean(p, 'unbiased');
+ this.examples = QualifiedParameters.readOrDefault(p, 'examples', []);
+ this.endOnFailure = QualifiedParameters.readBoolean(p, 'endOnFailure');
+ this.reporter = QualifiedParameters.readOrDefault(p, 'reporter', null);
+ this.asyncReporter = QualifiedParameters.readOrDefault(p, 'asyncReporter', null);
+ this.errorWithCause = QualifiedParameters.readBoolean(p, 'errorWithCause');
+ }
+ toParameters() {
+ const orUndefined = (value) => (value !== null ? value : undefined);
+ const parameters = {
+ seed: this.seed,
+ randomType: this.randomType,
+ numRuns: this.numRuns,
+ maxSkipsPerRun: this.maxSkipsPerRun,
+ timeout: orUndefined(this.timeout),
+ skipAllAfterTimeLimit: orUndefined(this.skipAllAfterTimeLimit),
+ interruptAfterTimeLimit: orUndefined(this.interruptAfterTimeLimit),
+ markInterruptAsFailure: this.markInterruptAsFailure,
+ skipEqualValues: this.skipEqualValues,
+ ignoreEqualValues: this.ignoreEqualValues,
+ path: this.path,
+ logger: this.logger,
+ unbiased: this.unbiased,
+ verbose: this.verbose,
+ examples: this.examples,
+ endOnFailure: this.endOnFailure,
+ reporter: orUndefined(this.reporter),
+ asyncReporter: orUndefined(this.asyncReporter),
+ errorWithCause: this.errorWithCause,
+ };
+ return parameters;
+ }
+ static read(op) {
+ return new QualifiedParameters(op);
+ }
+}
+QualifiedParameters.createQualifiedRandomGenerator = (random) => {
+ return (seed) => {
+ const rng = random(seed);
+ if (rng.unsafeJump === undefined) {
+ rng.unsafeJump = () => unsafeSkipN(rng, 42);
+ }
+ return rng;
+ };
+};
+QualifiedParameters.readSeed = (p) => {
+ if (p.seed == null)
+ return safeDateNow() ^ (safeMathRandom() * 0x100000000);
+ const seed32 = p.seed | 0;
+ if (p.seed === seed32)
+ return seed32;
+ const gap = p.seed - seed32;
+ return seed32 ^ (gap * 0x100000000);
+};
+QualifiedParameters.readRandomType = (p) => {
+ if (p.randomType == null)
+ return prand.xorshift128plus;
+ if (typeof p.randomType === 'string') {
+ switch (p.randomType) {
+ case 'mersenne':
+ return QualifiedParameters.createQualifiedRandomGenerator(prand.mersenne);
+ case 'congruential':
+ case 'congruential32':
+ return QualifiedParameters.createQualifiedRandomGenerator(prand.congruential32);
+ case 'xorshift128plus':
+ return prand.xorshift128plus;
+ case 'xoroshiro128plus':
+ return prand.xoroshiro128plus;
+ default:
+ throw new Error(`Invalid random specified: '${p.randomType}'`);
+ }
+ }
+ const mrng = p.randomType(0);
+ if ('min' in mrng && mrng.min !== -0x80000000) {
+ throw new Error(`Invalid random number generator: min must equal -0x80000000, got ${String(mrng.min)}`);
+ }
+ if ('max' in mrng && mrng.max !== 0x7fffffff) {
+ throw new Error(`Invalid random number generator: max must equal 0x7fffffff, got ${String(mrng.max)}`);
+ }
+ if ('unsafeJump' in mrng) {
+ return p.randomType;
+ }
+ return QualifiedParameters.createQualifiedRandomGenerator(p.randomType);
+};
+QualifiedParameters.readNumRuns = (p) => {
+ const defaultValue = 100;
+ if (p.numRuns != null)
+ return p.numRuns;
+ if (p.num_runs != null)
+ return p.num_runs;
+ return defaultValue;
+};
+QualifiedParameters.readVerbose = (p) => {
+ if (p.verbose == null)
+ return VerbosityLevel.None;
+ if (typeof p.verbose === 'boolean') {
+ return p.verbose === true ? VerbosityLevel.Verbose : VerbosityLevel.None;
+ }
+ if (p.verbose <= VerbosityLevel.None) {
+ return VerbosityLevel.None;
+ }
+ if (p.verbose >= VerbosityLevel.VeryVerbose) {
+ return VerbosityLevel.VeryVerbose;
+ }
+ return p.verbose | 0;
+};
+QualifiedParameters.readBoolean = (p, key) => p[key] === true;
+QualifiedParameters.readOrDefault = (p, key, defaultValue) => {
+ const value = p[key];
+ return value != null ? value : defaultValue;
+};
+QualifiedParameters.safeTimeout = (value) => {
+ if (value === null) {
+ return null;
+ }
+ return safeMathMin(value, 0x7fffffff);
+};
diff --git a/node_modules/fast-check/lib/esm/check/runner/configuration/RandomType.js b/node_modules/fast-check/lib/esm/check/runner/configuration/RandomType.js
new file mode 100644
index 0000000000000000000000000000000000000000..cb0ff5c3b541f646105198ee23ac0fc3d805023e
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/check/runner/configuration/RandomType.js
@@ -0,0 +1 @@
+export {};
diff --git a/node_modules/fast-check/lib/esm/check/runner/configuration/VerbosityLevel.js b/node_modules/fast-check/lib/esm/check/runner/configuration/VerbosityLevel.js
new file mode 100644
index 0000000000000000000000000000000000000000..264830862bd18fee97cfbfab2712598510668e05
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/check/runner/configuration/VerbosityLevel.js
@@ -0,0 +1,6 @@
+export var VerbosityLevel;
+(function (VerbosityLevel) {
+ VerbosityLevel[VerbosityLevel["None"] = 0] = "None";
+ VerbosityLevel[VerbosityLevel["Verbose"] = 1] = "Verbose";
+ VerbosityLevel[VerbosityLevel["VeryVerbose"] = 2] = "VeryVerbose";
+})(VerbosityLevel || (VerbosityLevel = {}));
diff --git a/node_modules/fast-check/lib/esm/check/runner/reporter/ExecutionStatus.js b/node_modules/fast-check/lib/esm/check/runner/reporter/ExecutionStatus.js
new file mode 100644
index 0000000000000000000000000000000000000000..f69957243596b47f979e0c2299580902a0665f61
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/check/runner/reporter/ExecutionStatus.js
@@ -0,0 +1,6 @@
+export var ExecutionStatus;
+(function (ExecutionStatus) {
+ ExecutionStatus[ExecutionStatus["Success"] = 0] = "Success";
+ ExecutionStatus[ExecutionStatus["Skipped"] = -1] = "Skipped";
+ ExecutionStatus[ExecutionStatus["Failure"] = 1] = "Failure";
+})(ExecutionStatus || (ExecutionStatus = {}));
diff --git a/node_modules/fast-check/lib/esm/check/runner/reporter/ExecutionTree.js b/node_modules/fast-check/lib/esm/check/runner/reporter/ExecutionTree.js
new file mode 100644
index 0000000000000000000000000000000000000000..cb0ff5c3b541f646105198ee23ac0fc3d805023e
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/check/runner/reporter/ExecutionTree.js
@@ -0,0 +1 @@
+export {};
diff --git a/node_modules/fast-check/lib/esm/check/runner/reporter/RunDetails.js b/node_modules/fast-check/lib/esm/check/runner/reporter/RunDetails.js
new file mode 100644
index 0000000000000000000000000000000000000000..cb0ff5c3b541f646105198ee23ac0fc3d805023e
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/check/runner/reporter/RunDetails.js
@@ -0,0 +1 @@
+export {};
diff --git a/node_modules/fast-check/lib/esm/check/runner/reporter/RunExecution.js b/node_modules/fast-check/lib/esm/check/runner/reporter/RunExecution.js
new file mode 100644
index 0000000000000000000000000000000000000000..5012f37d1327a2dfb5cdfa0145f0afd53d39eef8
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/check/runner/reporter/RunExecution.js
@@ -0,0 +1,114 @@
+import { VerbosityLevel } from '../configuration/VerbosityLevel.js';
+import { ExecutionStatus } from './ExecutionStatus.js';
+import { safeSplit } from '../../../utils/globals.js';
+export class RunExecution {
+ constructor(verbosity, interruptedAsFailure) {
+ this.verbosity = verbosity;
+ this.interruptedAsFailure = interruptedAsFailure;
+ this.isSuccess = () => this.pathToFailure == null;
+ this.firstFailure = () => (this.pathToFailure ? +safeSplit(this.pathToFailure, ':')[0] : -1);
+ this.numShrinks = () => (this.pathToFailure ? safeSplit(this.pathToFailure, ':').length - 1 : 0);
+ this.rootExecutionTrees = [];
+ this.currentLevelExecutionTrees = this.rootExecutionTrees;
+ this.failure = null;
+ this.numSkips = 0;
+ this.numSuccesses = 0;
+ this.interrupted = false;
+ }
+ appendExecutionTree(status, value) {
+ const currentTree = { status, value, children: [] };
+ this.currentLevelExecutionTrees.push(currentTree);
+ return currentTree;
+ }
+ fail(value, id, failure) {
+ if (this.verbosity >= VerbosityLevel.Verbose) {
+ const currentTree = this.appendExecutionTree(ExecutionStatus.Failure, value);
+ this.currentLevelExecutionTrees = currentTree.children;
+ }
+ if (this.pathToFailure == null)
+ this.pathToFailure = `${id}`;
+ else
+ this.pathToFailure += `:${id}`;
+ this.value = value;
+ this.failure = failure;
+ }
+ skip(value) {
+ if (this.verbosity >= VerbosityLevel.VeryVerbose) {
+ this.appendExecutionTree(ExecutionStatus.Skipped, value);
+ }
+ if (this.pathToFailure == null) {
+ ++this.numSkips;
+ }
+ }
+ success(value) {
+ if (this.verbosity >= VerbosityLevel.VeryVerbose) {
+ this.appendExecutionTree(ExecutionStatus.Success, value);
+ }
+ if (this.pathToFailure == null) {
+ ++this.numSuccesses;
+ }
+ }
+ interrupt() {
+ this.interrupted = true;
+ }
+ extractFailures() {
+ if (this.isSuccess()) {
+ return [];
+ }
+ const failures = [];
+ let cursor = this.rootExecutionTrees;
+ while (cursor.length > 0 && cursor[cursor.length - 1].status === ExecutionStatus.Failure) {
+ const failureTree = cursor[cursor.length - 1];
+ failures.push(failureTree.value);
+ cursor = failureTree.children;
+ }
+ return failures;
+ }
+ toRunDetails(seed, basePath, maxSkips, qParams) {
+ if (!this.isSuccess()) {
+ return {
+ failed: true,
+ interrupted: this.interrupted,
+ numRuns: this.firstFailure() + 1 - this.numSkips,
+ numSkips: this.numSkips,
+ numShrinks: this.numShrinks(),
+ seed,
+ counterexample: this.value,
+ counterexamplePath: RunExecution.mergePaths(basePath, this.pathToFailure),
+ error: this.failure.errorMessage,
+ errorInstance: this.failure.error,
+ failures: this.extractFailures(),
+ executionSummary: this.rootExecutionTrees,
+ verbose: this.verbosity,
+ runConfiguration: qParams.toParameters(),
+ };
+ }
+ const considerInterruptedAsFailure = this.interruptedAsFailure || this.numSuccesses === 0;
+ const failed = this.numSkips > maxSkips || (this.interrupted && considerInterruptedAsFailure);
+ const out = {
+ failed,
+ interrupted: this.interrupted,
+ numRuns: this.numSuccesses,
+ numSkips: this.numSkips,
+ numShrinks: 0,
+ seed,
+ counterexample: null,
+ counterexamplePath: null,
+ error: null,
+ errorInstance: null,
+ failures: [],
+ executionSummary: this.rootExecutionTrees,
+ verbose: this.verbosity,
+ runConfiguration: qParams.toParameters(),
+ };
+ return out;
+ }
+}
+RunExecution.mergePaths = (offsetPath, path) => {
+ if (offsetPath.length === 0)
+ return path;
+ const offsetItems = offsetPath.split(':');
+ const remainingItems = path.split(':');
+ const middle = +offsetItems[offsetItems.length - 1] + +remainingItems[0];
+ return [...offsetItems.slice(0, offsetItems.length - 1), `${middle}`, ...remainingItems.slice(1)].join(':');
+};
diff --git a/node_modules/fast-check/lib/esm/check/runner/utils/PathWalker.js b/node_modules/fast-check/lib/esm/check/runner/utils/PathWalker.js
new file mode 100644
index 0000000000000000000000000000000000000000..59b6fa0e4a3b65980742bdf3ff45f59eeace8edf
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/check/runner/utils/PathWalker.js
@@ -0,0 +1,22 @@
+function produce(producer) {
+ return producer();
+}
+export function pathWalk(path, initialProducers, shrink) {
+ const producers = initialProducers;
+ const segments = path.split(':').map((text) => +text);
+ if (segments.length === 0) {
+ return producers.map(produce);
+ }
+ if (!segments.every((v) => !Number.isNaN(v))) {
+ throw new Error(`Unable to replay, got invalid path=${path}`);
+ }
+ let values = producers.drop(segments[0]).map(produce);
+ for (const s of segments.slice(1)) {
+ const valueToShrink = values.getNthOrLast(0);
+ if (valueToShrink === null) {
+ throw new Error(`Unable to replay, got wrong path=${path}`);
+ }
+ values = shrink(valueToShrink).drop(s);
+ }
+ return values;
+}
diff --git a/node_modules/fast-check/lib/esm/check/runner/utils/RunDetailsFormatter.js b/node_modules/fast-check/lib/esm/check/runner/utils/RunDetailsFormatter.js
new file mode 100644
index 0000000000000000000000000000000000000000..d514dd93e9a4dd63b644b99d5c961918e6e5cfc1
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/check/runner/utils/RunDetailsFormatter.js
@@ -0,0 +1,161 @@
+import { Error, safeMapGet, Map, safePush, safeReplace } from '../../../utils/globals.js';
+import { stringify, possiblyAsyncStringify } from '../../../utils/stringify.js';
+import { VerbosityLevel } from '../configuration/VerbosityLevel.js';
+import { ExecutionStatus } from '../reporter/ExecutionStatus.js';
+const safeObjectAssign = Object.assign;
+function formatHints(hints) {
+ if (hints.length === 1) {
+ return `Hint: ${hints[0]}`;
+ }
+ return hints.map((h, idx) => `Hint (${idx + 1}): ${h}`).join('\n');
+}
+function formatFailures(failures, stringifyOne) {
+ return `Encountered failures were:\n- ${failures.map(stringifyOne).join('\n- ')}`;
+}
+function formatExecutionSummary(executionTrees, stringifyOne) {
+ const summaryLines = [];
+ const remainingTreesAndDepth = [];
+ for (const tree of executionTrees.slice().reverse()) {
+ remainingTreesAndDepth.push({ depth: 1, tree });
+ }
+ while (remainingTreesAndDepth.length !== 0) {
+ const currentTreeAndDepth = remainingTreesAndDepth.pop();
+ const currentTree = currentTreeAndDepth.tree;
+ const currentDepth = currentTreeAndDepth.depth;
+ const statusIcon = currentTree.status === ExecutionStatus.Success
+ ? '\x1b[32m\u221A\x1b[0m'
+ : currentTree.status === ExecutionStatus.Failure
+ ? '\x1b[31m\xD7\x1b[0m'
+ : '\x1b[33m!\x1b[0m';
+ const leftPadding = Array(currentDepth).join('. ');
+ summaryLines.push(`${leftPadding}${statusIcon} ${stringifyOne(currentTree.value)}`);
+ for (const tree of currentTree.children.slice().reverse()) {
+ remainingTreesAndDepth.push({ depth: currentDepth + 1, tree });
+ }
+ }
+ return `Execution summary:\n${summaryLines.join('\n')}`;
+}
+function preFormatTooManySkipped(out, stringifyOne) {
+ const message = `Failed to run property, too many pre-condition failures encountered\n{ seed: ${out.seed} }\n\nRan ${out.numRuns} time(s)\nSkipped ${out.numSkips} time(s)`;
+ let details = null;
+ const hints = [
+ 'Try to reduce the number of rejected values by combining map, flatMap and built-in arbitraries',
+ 'Increase failure tolerance by setting maxSkipsPerRun to an higher value',
+ ];
+ if (out.verbose >= VerbosityLevel.VeryVerbose) {
+ details = formatExecutionSummary(out.executionSummary, stringifyOne);
+ }
+ else {
+ safePush(hints, 'Enable verbose mode at level VeryVerbose in order to check all generated values and their associated status');
+ }
+ return { message, details, hints };
+}
+function preFormatFailure(out, stringifyOne) {
+ const noErrorInMessage = out.runConfiguration.errorWithCause;
+ const messageErrorPart = noErrorInMessage ? '' : `\nGot ${safeReplace(out.error, /^Error: /, 'error: ')}`;
+ const message = `Property failed after ${out.numRuns} tests\n{ seed: ${out.seed}, path: "${out.counterexamplePath}", endOnFailure: true }\nCounterexample: ${stringifyOne(out.counterexample)}\nShrunk ${out.numShrinks} time(s)${messageErrorPart}`;
+ let details = null;
+ const hints = [];
+ if (out.verbose >= VerbosityLevel.VeryVerbose) {
+ details = formatExecutionSummary(out.executionSummary, stringifyOne);
+ }
+ else if (out.verbose === VerbosityLevel.Verbose) {
+ details = formatFailures(out.failures, stringifyOne);
+ }
+ else {
+ safePush(hints, 'Enable verbose mode in order to have the list of all failing values encountered during the run');
+ }
+ return { message, details, hints };
+}
+function preFormatEarlyInterrupted(out, stringifyOne) {
+ const message = `Property interrupted after ${out.numRuns} tests\n{ seed: ${out.seed} }`;
+ let details = null;
+ const hints = [];
+ if (out.verbose >= VerbosityLevel.VeryVerbose) {
+ details = formatExecutionSummary(out.executionSummary, stringifyOne);
+ }
+ else {
+ safePush(hints, 'Enable verbose mode at level VeryVerbose in order to check all generated values and their associated status');
+ }
+ return { message, details, hints };
+}
+function defaultReportMessageInternal(out, stringifyOne) {
+ if (!out.failed)
+ return;
+ const { message, details, hints } = out.counterexamplePath === null
+ ? out.interrupted
+ ? preFormatEarlyInterrupted(out, stringifyOne)
+ : preFormatTooManySkipped(out, stringifyOne)
+ : preFormatFailure(out, stringifyOne);
+ let errorMessage = message;
+ if (details != null)
+ errorMessage += `\n\n${details}`;
+ if (hints.length > 0)
+ errorMessage += `\n\n${formatHints(hints)}`;
+ return errorMessage;
+}
+function defaultReportMessage(out) {
+ return defaultReportMessageInternal(out, stringify);
+}
+async function asyncDefaultReportMessage(out) {
+ const pendingStringifieds = [];
+ function stringifyOne(value) {
+ const stringified = possiblyAsyncStringify(value);
+ if (typeof stringified === 'string') {
+ return stringified;
+ }
+ pendingStringifieds.push(Promise.all([value, stringified]));
+ return '\u2026';
+ }
+ const firstTryMessage = defaultReportMessageInternal(out, stringifyOne);
+ if (pendingStringifieds.length === 0) {
+ return firstTryMessage;
+ }
+ const registeredValues = new Map(await Promise.all(pendingStringifieds));
+ function stringifySecond(value) {
+ const asyncStringifiedIfRegistered = safeMapGet(registeredValues, value);
+ if (asyncStringifiedIfRegistered !== undefined) {
+ return asyncStringifiedIfRegistered;
+ }
+ return stringify(value);
+ }
+ return defaultReportMessageInternal(out, stringifySecond);
+}
+function buildError(errorMessage, out) {
+ if (!out.runConfiguration.errorWithCause) {
+ throw new Error(errorMessage);
+ }
+ const ErrorWithCause = Error;
+ const error = new ErrorWithCause(errorMessage, { cause: out.errorInstance });
+ if (!('cause' in error)) {
+ safeObjectAssign(error, { cause: out.errorInstance });
+ }
+ return error;
+}
+function throwIfFailed(out) {
+ if (!out.failed)
+ return;
+ throw buildError(defaultReportMessage(out), out);
+}
+async function asyncThrowIfFailed(out) {
+ if (!out.failed)
+ return;
+ throw buildError(await asyncDefaultReportMessage(out), out);
+}
+export function reportRunDetails(out) {
+ if (out.runConfiguration.asyncReporter)
+ return out.runConfiguration.asyncReporter(out);
+ else if (out.runConfiguration.reporter)
+ return out.runConfiguration.reporter(out);
+ else
+ return throwIfFailed(out);
+}
+export async function asyncReportRunDetails(out) {
+ if (out.runConfiguration.asyncReporter)
+ return out.runConfiguration.asyncReporter(out);
+ else if (out.runConfiguration.reporter)
+ return out.runConfiguration.reporter(out);
+ else
+ return asyncThrowIfFailed(out);
+}
+export { defaultReportMessage, asyncDefaultReportMessage };
diff --git a/node_modules/fast-check/lib/esm/check/symbols.js b/node_modules/fast-check/lib/esm/check/symbols.js
new file mode 100644
index 0000000000000000000000000000000000000000..c6a68f59f90180a9db118384bda0d0b45688cfa2
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/check/symbols.js
@@ -0,0 +1,10 @@
+export const cloneMethod = Symbol.for('fast-check/cloneMethod');
+export function hasCloneMethod(instance) {
+ return (instance !== null &&
+ (typeof instance === 'object' || typeof instance === 'function') &&
+ cloneMethod in instance &&
+ typeof instance[cloneMethod] === 'function');
+}
+export function cloneIfNeeded(instance) {
+ return hasCloneMethod(instance) ? instance[cloneMethod]() : instance;
+}
diff --git a/node_modules/fast-check/lib/esm/fast-check-default.js b/node_modules/fast-check/lib/esm/fast-check-default.js
new file mode 100644
index 0000000000000000000000000000000000000000..cdaa76c11f96775fc704600737f81083d0897f7a
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/fast-check-default.js
@@ -0,0 +1,112 @@
+import { pre } from './check/precondition/Pre.js';
+import { asyncProperty } from './check/property/AsyncProperty.js';
+import { property } from './check/property/Property.js';
+import { assert, check } from './check/runner/Runner.js';
+import { sample, statistics } from './check/runner/Sampler.js';
+import { gen } from './arbitrary/gen.js';
+import { array } from './arbitrary/array.js';
+import { bigInt } from './arbitrary/bigInt.js';
+import { bigIntN } from './arbitrary/bigIntN.js';
+import { bigUint } from './arbitrary/bigUint.js';
+import { bigUintN } from './arbitrary/bigUintN.js';
+import { boolean } from './arbitrary/boolean.js';
+import { falsy } from './arbitrary/falsy.js';
+import { ascii } from './arbitrary/ascii.js';
+import { base64 } from './arbitrary/base64.js';
+import { char } from './arbitrary/char.js';
+import { char16bits } from './arbitrary/char16bits.js';
+import { fullUnicode } from './arbitrary/fullUnicode.js';
+import { hexa } from './arbitrary/hexa.js';
+import { unicode } from './arbitrary/unicode.js';
+import { constant } from './arbitrary/constant.js';
+import { constantFrom } from './arbitrary/constantFrom.js';
+import { context } from './arbitrary/context.js';
+import { date } from './arbitrary/date.js';
+import { clone } from './arbitrary/clone.js';
+import { dictionary } from './arbitrary/dictionary.js';
+import { emailAddress } from './arbitrary/emailAddress.js';
+import { double } from './arbitrary/double.js';
+import { float } from './arbitrary/float.js';
+import { compareBooleanFunc } from './arbitrary/compareBooleanFunc.js';
+import { compareFunc } from './arbitrary/compareFunc.js';
+import { func } from './arbitrary/func.js';
+import { domain } from './arbitrary/domain.js';
+import { integer } from './arbitrary/integer.js';
+import { maxSafeInteger } from './arbitrary/maxSafeInteger.js';
+import { maxSafeNat } from './arbitrary/maxSafeNat.js';
+import { nat } from './arbitrary/nat.js';
+import { ipV4 } from './arbitrary/ipV4.js';
+import { ipV4Extended } from './arbitrary/ipV4Extended.js';
+import { ipV6 } from './arbitrary/ipV6.js';
+import { letrec } from './arbitrary/letrec.js';
+import { lorem } from './arbitrary/lorem.js';
+import { mapToConstant } from './arbitrary/mapToConstant.js';
+import { memo } from './arbitrary/memo.js';
+import { mixedCase } from './arbitrary/mixedCase.js';
+import { object } from './arbitrary/object.js';
+import { json } from './arbitrary/json.js';
+import { anything } from './arbitrary/anything.js';
+import { unicodeJsonValue } from './arbitrary/unicodeJsonValue.js';
+import { jsonValue } from './arbitrary/jsonValue.js';
+import { unicodeJson } from './arbitrary/unicodeJson.js';
+import { oneof } from './arbitrary/oneof.js';
+import { option } from './arbitrary/option.js';
+import { record } from './arbitrary/record.js';
+import { uniqueArray } from './arbitrary/uniqueArray.js';
+import { infiniteStream } from './arbitrary/infiniteStream.js';
+import { asciiString } from './arbitrary/asciiString.js';
+import { base64String } from './arbitrary/base64String.js';
+import { fullUnicodeString } from './arbitrary/fullUnicodeString.js';
+import { hexaString } from './arbitrary/hexaString.js';
+import { string } from './arbitrary/string.js';
+import { string16bits } from './arbitrary/string16bits.js';
+import { stringOf } from './arbitrary/stringOf.js';
+import { unicodeString } from './arbitrary/unicodeString.js';
+import { subarray } from './arbitrary/subarray.js';
+import { shuffledSubarray } from './arbitrary/shuffledSubarray.js';
+import { tuple } from './arbitrary/tuple.js';
+import { ulid } from './arbitrary/ulid.js';
+import { uuid } from './arbitrary/uuid.js';
+import { uuidV } from './arbitrary/uuidV.js';
+import { webAuthority } from './arbitrary/webAuthority.js';
+import { webFragments } from './arbitrary/webFragments.js';
+import { webPath } from './arbitrary/webPath.js';
+import { webQueryParameters } from './arbitrary/webQueryParameters.js';
+import { webSegment } from './arbitrary/webSegment.js';
+import { webUrl } from './arbitrary/webUrl.js';
+import { commands } from './arbitrary/commands.js';
+import { asyncModelRun, modelRun, scheduledModelRun } from './check/model/ModelRunner.js';
+import { Random } from './random/generator/Random.js';
+import { configureGlobal, readConfigureGlobal, resetConfigureGlobal, } from './check/runner/configuration/GlobalParameters.js';
+import { VerbosityLevel } from './check/runner/configuration/VerbosityLevel.js';
+import { ExecutionStatus } from './check/runner/reporter/ExecutionStatus.js';
+import { cloneMethod, cloneIfNeeded, hasCloneMethod } from './check/symbols.js';
+import { Stream, stream } from './stream/Stream.js';
+import { hash } from './utils/hash.js';
+import { stringify, asyncStringify, toStringMethod, hasToStringMethod, asyncToStringMethod, hasAsyncToStringMethod, } from './utils/stringify.js';
+import { scheduler, schedulerFor } from './arbitrary/scheduler.js';
+import { defaultReportMessage, asyncDefaultReportMessage } from './check/runner/utils/RunDetailsFormatter.js';
+import { PreconditionFailure } from './check/precondition/PreconditionFailure.js';
+import { int8Array } from './arbitrary/int8Array.js';
+import { int16Array } from './arbitrary/int16Array.js';
+import { int32Array } from './arbitrary/int32Array.js';
+import { uint8Array } from './arbitrary/uint8Array.js';
+import { uint8ClampedArray } from './arbitrary/uint8ClampedArray.js';
+import { uint16Array } from './arbitrary/uint16Array.js';
+import { uint32Array } from './arbitrary/uint32Array.js';
+import { float32Array } from './arbitrary/float32Array.js';
+import { float64Array } from './arbitrary/float64Array.js';
+import { sparseArray } from './arbitrary/sparseArray.js';
+import { Arbitrary } from './check/arbitrary/definition/Arbitrary.js';
+import { Value } from './check/arbitrary/definition/Value.js';
+import { createDepthIdentifier, getDepthContextFor } from './arbitrary/_internals/helpers/DepthContext.js';
+import { bigInt64Array } from './arbitrary/bigInt64Array.js';
+import { bigUint64Array } from './arbitrary/bigUint64Array.js';
+import { stringMatching } from './arbitrary/stringMatching.js';
+import { noShrink } from './arbitrary/noShrink.js';
+import { noBias } from './arbitrary/noBias.js';
+import { limitShrink } from './arbitrary/limitShrink.js';
+const __type = 'module';
+const __version = '3.23.2';
+const __commitHash = 'a4a600eaa08c833707067a877db144289a724b91';
+export { __type, __version, __commitHash, sample, statistics, check, assert, pre, PreconditionFailure, property, asyncProperty, boolean, falsy, float, double, integer, nat, maxSafeInteger, maxSafeNat, bigIntN, bigUintN, bigInt, bigUint, char, ascii, char16bits, unicode, fullUnicode, hexa, base64, mixedCase, string, asciiString, string16bits, stringOf, unicodeString, fullUnicodeString, hexaString, base64String, stringMatching, limitShrink, lorem, constant, constantFrom, mapToConstant, option, oneof, clone, noBias, noShrink, shuffledSubarray, subarray, array, sparseArray, infiniteStream, uniqueArray, tuple, record, dictionary, anything, object, json, jsonValue, unicodeJson, unicodeJsonValue, letrec, memo, compareBooleanFunc, compareFunc, func, context, gen, date, ipV4, ipV4Extended, ipV6, domain, webAuthority, webSegment, webFragments, webPath, webQueryParameters, webUrl, emailAddress, ulid, uuid, uuidV, int8Array, uint8Array, uint8ClampedArray, int16Array, uint16Array, int32Array, uint32Array, float32Array, float64Array, bigInt64Array, bigUint64Array, asyncModelRun, modelRun, scheduledModelRun, commands, scheduler, schedulerFor, Arbitrary, Value, cloneMethod, cloneIfNeeded, hasCloneMethod, toStringMethod, hasToStringMethod, asyncToStringMethod, hasAsyncToStringMethod, getDepthContextFor, stringify, asyncStringify, defaultReportMessage, asyncDefaultReportMessage, hash, VerbosityLevel, configureGlobal, readConfigureGlobal, resetConfigureGlobal, ExecutionStatus, Random, Stream, stream, createDepthIdentifier, };
diff --git a/node_modules/fast-check/lib/esm/fast-check.js b/node_modules/fast-check/lib/esm/fast-check.js
new file mode 100644
index 0000000000000000000000000000000000000000..15a2b48518f714195ae7a199f849ac667eed4266
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/fast-check.js
@@ -0,0 +1,3 @@
+import * as fc from './fast-check-default.js';
+export default fc;
+export * from './fast-check-default.js';
diff --git a/node_modules/fast-check/lib/esm/package.json b/node_modules/fast-check/lib/esm/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..3dbc1ca591c0557e35b6004aeba250e6a70b56e3
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/package.json
@@ -0,0 +1,3 @@
+{
+ "type": "module"
+}
diff --git a/node_modules/fast-check/lib/esm/random/generator/Random.js b/node_modules/fast-check/lib/esm/random/generator/Random.js
new file mode 100644
index 0000000000000000000000000000000000000000..772a0f47540b485938cf5942495c0082b38f87ae
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/random/generator/Random.js
@@ -0,0 +1,39 @@
+import { unsafeUniformArrayIntDistribution, unsafeUniformBigIntDistribution, unsafeUniformIntDistribution, } from 'pure-rand';
+export class Random {
+ constructor(sourceRng) {
+ this.internalRng = sourceRng.clone();
+ }
+ clone() {
+ return new Random(this.internalRng);
+ }
+ next(bits) {
+ return unsafeUniformIntDistribution(0, (1 << bits) - 1, this.internalRng);
+ }
+ nextBoolean() {
+ return unsafeUniformIntDistribution(0, 1, this.internalRng) == 1;
+ }
+ nextInt(min, max) {
+ return unsafeUniformIntDistribution(min == null ? Random.MIN_INT : min, max == null ? Random.MAX_INT : max, this.internalRng);
+ }
+ nextBigInt(min, max) {
+ return unsafeUniformBigIntDistribution(min, max, this.internalRng);
+ }
+ nextArrayInt(min, max) {
+ return unsafeUniformArrayIntDistribution(min, max, this.internalRng);
+ }
+ nextDouble() {
+ const a = this.next(26);
+ const b = this.next(27);
+ return (a * Random.DBL_FACTOR + b) * Random.DBL_DIVISOR;
+ }
+ getState() {
+ if ('getState' in this.internalRng && typeof this.internalRng.getState === 'function') {
+ return this.internalRng.getState();
+ }
+ return undefined;
+ }
+}
+Random.MIN_INT = 0x80000000 | 0;
+Random.MAX_INT = 0x7fffffff | 0;
+Random.DBL_FACTOR = Math.pow(2, 27);
+Random.DBL_DIVISOR = Math.pow(2, -53);
diff --git a/node_modules/fast-check/lib/esm/stream/LazyIterableIterator.js b/node_modules/fast-check/lib/esm/stream/LazyIterableIterator.js
new file mode 100644
index 0000000000000000000000000000000000000000..1ede07757c4aedcb8ad501a19c741632344ba988
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/stream/LazyIterableIterator.js
@@ -0,0 +1,20 @@
+class LazyIterableIterator {
+ constructor(producer) {
+ this.producer = producer;
+ }
+ [Symbol.iterator]() {
+ if (this.it === undefined) {
+ this.it = this.producer();
+ }
+ return this.it;
+ }
+ next() {
+ if (this.it === undefined) {
+ this.it = this.producer();
+ }
+ return this.it.next();
+ }
+}
+export function makeLazy(producer) {
+ return new LazyIterableIterator(producer);
+}
diff --git a/node_modules/fast-check/lib/esm/stream/Stream.js b/node_modules/fast-check/lib/esm/stream/Stream.js
new file mode 100644
index 0000000000000000000000000000000000000000..9b87dab430f62917743894c742d46a988a929c21
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/stream/Stream.js
@@ -0,0 +1,86 @@
+import { filterHelper, flatMapHelper, joinHelper, mapHelper, nilHelper, takeNHelper, takeWhileHelper, } from './StreamHelpers.js';
+const safeSymbolIterator = Symbol.iterator;
+export class Stream {
+ static nil() {
+ return new Stream(nilHelper());
+ }
+ static of(...elements) {
+ return new Stream(elements[safeSymbolIterator]());
+ }
+ constructor(g) {
+ this.g = g;
+ }
+ next() {
+ return this.g.next();
+ }
+ [Symbol.iterator]() {
+ return this.g;
+ }
+ map(f) {
+ return new Stream(mapHelper(this.g, f));
+ }
+ flatMap(f) {
+ return new Stream(flatMapHelper(this.g, f));
+ }
+ dropWhile(f) {
+ let foundEligible = false;
+ function* helper(v) {
+ if (foundEligible || !f(v)) {
+ foundEligible = true;
+ yield v;
+ }
+ }
+ return this.flatMap(helper);
+ }
+ drop(n) {
+ if (n <= 0) {
+ return this;
+ }
+ let idx = 0;
+ function helper() {
+ return idx++ < n;
+ }
+ return this.dropWhile(helper);
+ }
+ takeWhile(f) {
+ return new Stream(takeWhileHelper(this.g, f));
+ }
+ take(n) {
+ return new Stream(takeNHelper(this.g, n));
+ }
+ filter(f) {
+ return new Stream(filterHelper(this.g, f));
+ }
+ every(f) {
+ for (const v of this.g) {
+ if (!f(v)) {
+ return false;
+ }
+ }
+ return true;
+ }
+ has(f) {
+ for (const v of this.g) {
+ if (f(v)) {
+ return [true, v];
+ }
+ }
+ return [false, null];
+ }
+ join(...others) {
+ return new Stream(joinHelper(this.g, others));
+ }
+ getNthOrLast(nth) {
+ let remaining = nth;
+ let last = null;
+ for (const v of this.g) {
+ if (remaining-- === 0)
+ return v;
+ last = v;
+ }
+ return last;
+ }
+}
+export function stream(g) {
+ return new Stream(g);
+}
diff --git a/node_modules/fast-check/lib/esm/stream/StreamHelpers.js b/node_modules/fast-check/lib/esm/stream/StreamHelpers.js
new file mode 100644
index 0000000000000000000000000000000000000000..38457e85e48410579d1a6e540aa97ae807ed5d62
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/stream/StreamHelpers.js
@@ -0,0 +1,55 @@
+class Nil {
+ [Symbol.iterator]() {
+ return this;
+ }
+ next(value) {
+ return { value, done: true };
+ }
+}
+Nil.nil = new Nil();
+export function nilHelper() {
+ return Nil.nil;
+}
+export function* mapHelper(g, f) {
+ for (const v of g) {
+ yield f(v);
+ }
+}
+export function* flatMapHelper(g, f) {
+ for (const v of g) {
+ yield* f(v);
+ }
+}
+export function* filterHelper(g, f) {
+ for (const v of g) {
+ if (f(v)) {
+ yield v;
+ }
+ }
+}
+export function* takeNHelper(g, n) {
+ for (let i = 0; i < n; ++i) {
+ const cur = g.next();
+ if (cur.done) {
+ break;
+ }
+ yield cur.value;
+ }
+}
+export function* takeWhileHelper(g, f) {
+ let cur = g.next();
+ while (!cur.done && f(cur.value)) {
+ yield cur.value;
+ cur = g.next();
+ }
+}
+export function* joinHelper(g, others) {
+ for (let cur = g.next(); !cur.done; cur = g.next()) {
+ yield cur.value;
+ }
+ for (const s of others) {
+ for (let cur = s.next(); !cur.done; cur = s.next()) {
+ yield cur.value;
+ }
+ }
+}
diff --git a/node_modules/fast-check/lib/esm/types/arbitrary/_internals/AdapterArbitrary.d.ts b/node_modules/fast-check/lib/esm/types/arbitrary/_internals/AdapterArbitrary.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..cb0ff5c3b541f646105198ee23ac0fc3d805023e
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/types/arbitrary/_internals/AdapterArbitrary.d.ts
@@ -0,0 +1 @@
+export {};
diff --git a/node_modules/fast-check/lib/esm/types/arbitrary/_internals/AlwaysShrinkableArbitrary.d.ts b/node_modules/fast-check/lib/esm/types/arbitrary/_internals/AlwaysShrinkableArbitrary.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..cb0ff5c3b541f646105198ee23ac0fc3d805023e
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/types/arbitrary/_internals/AlwaysShrinkableArbitrary.d.ts
@@ -0,0 +1 @@
+export {};
diff --git a/node_modules/fast-check/lib/esm/types/arbitrary/_internals/ArrayArbitrary.d.ts b/node_modules/fast-check/lib/esm/types/arbitrary/_internals/ArrayArbitrary.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..cb0ff5c3b541f646105198ee23ac0fc3d805023e
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/types/arbitrary/_internals/ArrayArbitrary.d.ts
@@ -0,0 +1 @@
+export {};
diff --git a/node_modules/fast-check/lib/esm/types/arbitrary/_internals/ArrayInt64Arbitrary.d.ts b/node_modules/fast-check/lib/esm/types/arbitrary/_internals/ArrayInt64Arbitrary.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..cb0ff5c3b541f646105198ee23ac0fc3d805023e
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/types/arbitrary/_internals/ArrayInt64Arbitrary.d.ts
@@ -0,0 +1 @@
+export {};
diff --git a/node_modules/fast-check/lib/esm/types/arbitrary/_internals/BigIntArbitrary.d.ts b/node_modules/fast-check/lib/esm/types/arbitrary/_internals/BigIntArbitrary.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..cb0ff5c3b541f646105198ee23ac0fc3d805023e
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/types/arbitrary/_internals/BigIntArbitrary.d.ts
@@ -0,0 +1 @@
+export {};
diff --git a/node_modules/fast-check/lib/esm/types/arbitrary/_internals/CloneArbitrary.d.ts b/node_modules/fast-check/lib/esm/types/arbitrary/_internals/CloneArbitrary.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..cb0ff5c3b541f646105198ee23ac0fc3d805023e
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/types/arbitrary/_internals/CloneArbitrary.d.ts
@@ -0,0 +1 @@
+export {};
diff --git a/node_modules/fast-check/lib/esm/types/arbitrary/_internals/CommandsArbitrary.d.ts b/node_modules/fast-check/lib/esm/types/arbitrary/_internals/CommandsArbitrary.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..cb0ff5c3b541f646105198ee23ac0fc3d805023e
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/types/arbitrary/_internals/CommandsArbitrary.d.ts
@@ -0,0 +1 @@
+export {};
diff --git a/node_modules/fast-check/lib/esm/types/arbitrary/_internals/ConstantArbitrary.d.ts b/node_modules/fast-check/lib/esm/types/arbitrary/_internals/ConstantArbitrary.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..cb0ff5c3b541f646105198ee23ac0fc3d805023e
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/types/arbitrary/_internals/ConstantArbitrary.d.ts
@@ -0,0 +1 @@
+export {};
diff --git a/node_modules/fast-check/lib/esm/types/arbitrary/_internals/FrequencyArbitrary.d.ts b/node_modules/fast-check/lib/esm/types/arbitrary/_internals/FrequencyArbitrary.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..cb0ff5c3b541f646105198ee23ac0fc3d805023e
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/types/arbitrary/_internals/FrequencyArbitrary.d.ts
@@ -0,0 +1 @@
+export {};
diff --git a/node_modules/fast-check/lib/esm/types/arbitrary/_internals/GeneratorArbitrary.d.ts b/node_modules/fast-check/lib/esm/types/arbitrary/_internals/GeneratorArbitrary.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e048092905797b9836ea2c40167a54f285832acb
--- /dev/null
+++ b/node_modules/fast-check/lib/esm/types/arbitrary/_internals/GeneratorArbitrary.d.ts
@@ -0,0 +1,16 @@
+import { Arbitrary } from '../../check/arbitrary/definition/Arbitrary.js';
+import type { Value } from '../../check/arbitrary/definition/Value.js';
+import type { Random } from '../../random/generator/Random.js';
+import { Stream } from '../../stream/Stream.js';
+import type { GeneratorValue } from './builders/GeneratorValueBuilder.js';
+/**
+ * The generator arbitrary is responsible to generate instances of {@link GeneratorValue}.
+ * These instances can be used to produce "random values" within the tests themselves while still
+ * providing a bit of shrinking capabilities (not all).
+ */
+export declare class GeneratorArbitrary extends Arbitrary