@codingame/monaco-vscode-api 2.0.3 → 2.1.0-update-vscode-1.86.1

package/vscode/src/vs/platform/quickinput/browser/quickInputList.js

@@ -16,7 +16,7 @@ import { OS, isMacintosh } from '../../../base/common/platform.js';
 import { ltrim } from '../../../base/common/strings.js';
 import './media/quickInput.css.js';
 import { localizeWithPath } from '../../../nls.js';
-import { getIconClass } from './quickInputUtils.js';
+import { quickInputButtonToAction } from './quickInputUtils.js';
 import { Lazy } from '../../../base/common/lazy.js';
 import { URI } from '../../../base/common/uri.js';
 import { isDark } from '../../theme/common/theme.js';
@@ -122,8 +122,9 @@ class ListElement {
 }
 class ListElementRenderer {
     static { this.ID = 'listelement'; }
-    constructor(themeService) {
+    constructor(themeService, hoverDelegate) {
         this.themeService = themeService;
+        this.hoverDelegate = hoverDelegate;
     }
     get templateId() {
         return ListElementRenderer.ID;
@@ -149,17 +150,23 @@ class ListElementRenderer {
         const row2 = append(rows, $('.quick-input-list-row'));
         data.label = ( new IconLabel(
             row1,
-            { supportHighlights: true, supportDescriptionHighlights: true, supportIcons: true }
+            { supportHighlights: true, supportDescriptionHighlights: true, supportIcons: true, hoverDelegate: this.hoverDelegate }
         ));
         data.toDisposeTemplate.push(data.label);
         data.icon = prepend(data.label.element, $('.quick-input-list-icon'));
         const keybindingContainer = append(row1, $('.quick-input-list-entry-keybinding'));
         data.keybinding = ( new KeybindingLabel(keybindingContainer, OS));
         const detailContainer = append(row2, $('.quick-input-list-label-meta'));
-        data.detail = ( new IconLabel(detailContainer, { supportHighlights: true, supportIcons: true }));
+        data.detail = ( new IconLabel(
+            detailContainer,
+            { supportHighlights: true, supportIcons: true, hoverDelegate: this.hoverDelegate }
+        ));
         data.toDisposeTemplate.push(data.detail);
         data.separator = append(data.entry, $('.quick-input-list-separator'));
-        data.actionBar = ( new ActionBar(data.entry));
+        data.actionBar = ( new ActionBar(
+            data.entry,
+            this.hoverDelegate ? { hoverDelegate: this.hoverDelegate } : undefined
+        ));
         data.actionBar.domNode.classList.add('quick-input-list-entry-action-bar');
         data.toDisposeTemplate.push(data.actionBar);
         return data;
@@ -183,7 +190,7 @@ class ListElementRenderer {
         }
         const options = {
             matches: labelHighlights || [],
-            descriptionTitle: element.saneDescription,
+            descriptionTitle: element.saneTooltip ? undefined : element.saneDescription,
             descriptionMatches: descriptionHighlights || [],
             labelEscapeNewLines: true
         };
@@ -202,7 +209,7 @@ class ListElementRenderer {
             data.detail.element.style.display = '';
             data.detail.setLabel(element.saneDetail, undefined, {
                 matches: detailHighlights,
-                title: element.saneDetail,
+                title: element.saneTooltip ? undefined : element.saneDetail,
                 labelEscapeNewLines: true
             });
         }
@@ -219,30 +226,11 @@ class ListElementRenderer {
         data.entry.classList.toggle('quick-input-list-separator-border', !!element.separator);
         const buttons = mainItem.buttons;
         if (buttons && buttons.length) {
-            data.actionBar.push(( buttons.map((button, index) => {
-                let cssClasses = button.iconClass || (button.iconPath ? getIconClass(button.iconPath) : undefined);
-                if (button.alwaysVisible) {
-                    cssClasses = cssClasses ? `${cssClasses} always-visible` : 'always-visible';
-                }
-                return {
-                    id: `id-${index}`,
-                    class: cssClasses,
-                    enabled: true,
-                    label: '',
-                    tooltip: button.tooltip || '',
-                    run: () => {
-                        mainItem.type !== 'separator'
-                            ? element.fireButtonTriggered({
-                                button,
-                                item: mainItem
-                            })
-                            : element.fireSeparatorButtonTriggered({
-                                button,
-                                separator: mainItem
-                            });
-                    }
-                };
-            })), { icon: true, label: false });
+            data.actionBar.push(( buttons.map(
+                (button, index) => quickInputButtonToAction(button, `id-${index}`, () => mainItem.type !== 'separator'
+                    ? element.fireButtonTriggered({ button, item: mainItem })
+                    : element.fireSeparatorButtonTriggered({ button, separator: mainItem }))
+            )), { icon: true, label: false });
             data.entry.classList.add('has-actions');
         }
         else {
@@ -316,7 +304,7 @@ class QuickInputList {
         this.container = append(this.parent, $('.quick-input-list'));
         const delegate = ( new ListElementDelegate());
         const accessibilityProvider = ( new QuickInputAccessibilityProvider());
-        this.list = options.createList('QuickInput', this.container, delegate, [( new ListElementRenderer(themeService))], {
+        this.list = options.createList('QuickInput', this.container, delegate, [( new ListElementRenderer(themeService, options.hoverDelegate))], {
             identityProvider: {
                 getId: element => {
                     return element.item?.id
@@ -380,39 +368,37 @@ class QuickInputList {
                 this.list.setSelection([e.index]);
             }
         }));
-        if (options.hoverDelegate) {
-            const delayer = ( new ThrottledDelayer(options.hoverDelegate.delay));
-            this.disposables.push(this.list.onMouseOver(async (e) => {
-                if (e.browserEvent.target instanceof HTMLAnchorElement) {
-                    delayer.cancel();
-                    return;
-                }
-                if (
-                !(e.browserEvent.relatedTarget instanceof HTMLAnchorElement) &&
-                    isAncestor(e.browserEvent.relatedTarget, e.element?.element)) {
-                    return;
-                }
-                try {
-                    await delayer.trigger(async () => {
-                        if (e.element) {
-                            this.showHover(e.element);
-                        }
-                    });
-                }
-                catch (e) {
-                    if (!isCancellationError(e)) {
-                        throw e;
+        const delayer = ( new ThrottledDelayer(options.hoverDelegate.delay));
+        this.disposables.push(this.list.onMouseOver(async (e) => {
+            if (e.browserEvent.target instanceof HTMLAnchorElement) {
+                delayer.cancel();
+                return;
+            }
+            if (
+            !(e.browserEvent.relatedTarget instanceof HTMLAnchorElement) &&
+                isAncestor(e.browserEvent.relatedTarget, e.element?.element)) {
+                return;
+            }
+            try {
+                await delayer.trigger(async () => {
+                    if (e.element) {
+                        this.showHover(e.element);
                     }
+                });
+            }
+            catch (e) {
+                if (!isCancellationError(e)) {
+                    throw e;
                 }
-            }));
-            this.disposables.push(this.list.onMouseOut(e => {
-                if (isAncestor(e.browserEvent.relatedTarget, e.element?.element)) {
-                    return;
-                }
-                delayer.cancel();
-            }));
-            this.disposables.push(delayer);
-        }
+            }
+        }));
+        this.disposables.push(this.list.onMouseOut(e => {
+            if (isAncestor(e.browserEvent.relatedTarget, e.element?.element)) {
+                return;
+            }
+            delayer.cancel();
+        }));
+        this.disposables.push(delayer);
         this.disposables.push(this._listElementChecked.event(_ => this.fireCheckedEvents()));
         this.disposables.push(this._onChangedAllVisibleChecked, this._onChangedCheckedCount, this._onChangedVisibleCount, this._onChangedCheckedElements, this._onButtonTriggered, this._onSeparatorButtonTriggered, this._onLeave, this._onKeyDown);
     }
@@ -627,9 +613,6 @@ class QuickInputList {
         this.list.domFocus();
     }
     showHover(element) {
-        if (this.options.hoverDelegate === undefined) {
-            return;
-        }
         if (this._lastHover && !this._lastHover.isDisposed) {
             this.options.hoverDelegate.onDidHideHover?.();
             this._lastHover?.dispose();

package/vscode/src/vs/platform/quickinput/browser/quickInputService.js

@@ -10,7 +10,10 @@ import { QuickAccessController } from './quickAccess.js';
 import { defaultInputBoxStyles, defaultToggleStyles, defaultCountBadgeStyles, defaultButtonStyles, defaultProgressBarStyles, defaultKeybindingLabelStyles, getListStyles } from '../../theme/browser/defaultStyles.js';
 import { asCssVariable, quickInputBackground, quickInputForeground, quickInputTitleBackground, widgetBorder, widgetShadow, quickInputListFocusBackground, quickInputListFocusForeground, quickInputListFocusIconForeground, activeContrastBorder, pickerGroupBorder, pickerGroupForeground } from '../../theme/common/colorRegistry.js';
 import { Themable, IThemeService } from '../../theme/common/themeService.js';
+import { QuickInputHoverDelegate } from './quickInput.js';
 import { QuickInputController } from './quickInputController.js';
+import { IConfigurationService } from '../../configuration/common/configuration.js';
+import { IHoverService } from '../../hover/browser/hover.js';
 let QuickInputService = class QuickInputService extends Themable {
     get backButton() { return this.controller.backButton; }
     get controller() {
@@ -26,11 +29,13 @@ let QuickInputService = class QuickInputService extends Themable {
         }
         return this._quickAccess;
     }
-    constructor(instantiationService, contextKeyService, themeService, layoutService) {
+    constructor(instantiationService, contextKeyService, themeService, layoutService, configurationService, hoverService) {
         super(themeService);
         this.instantiationService = instantiationService;
         this.contextKeyService = contextKeyService;
         this.layoutService = layoutService;
+        this.configurationService = configurationService;
+        this.hoverService = hoverService;
         this._onShow = this._register(( new Emitter()));
         this.onShow = this._onShow.event;
         this._onHide = this._register(( new Emitter()));
@@ -52,7 +57,8 @@ let QuickInputService = class QuickInputService extends Themable {
             },
             returnFocus: () => host.focus(),
             createList: (user, container, delegate, renderers, options) => this.instantiationService.createInstance(WorkbenchList, user, container, delegate, renderers, options),
-            styles: this.computeStyles()
+            styles: this.computeStyles(),
+            hoverDelegate: ( new QuickInputHoverDelegate(this.configurationService, this.hoverService))
         };
         const controller = this._register(( new QuickInputController({
             ...defaultOptions,
@@ -173,6 +179,8 @@ QuickInputService = ( __decorate([
     ( __param(0, IInstantiationService)),
     ( __param(1, IContextKeyService)),
     ( __param(2, IThemeService)),
-    ( __param(3, ILayoutService))
+    ( __param(3, ILayoutService)),
+    ( __param(4, IConfigurationService)),
+    ( __param(5, IHoverService))
 ], QuickInputService));
 export { QuickInputService };

package/vscode/src/vs/platform/quickinput/browser/quickInputUtils.js

@@ -1,4 +1,4 @@
-import { createCSSRule, asCSSUrl, reset, $, EventType, isEventLike, EventHelper } from '../../../base/browser/dom.js';
+import { reset, $, EventType, createCSSRule, asCSSUrl, isEventLike, EventHelper } from '../../../base/browser/dom.js';
 import { DomEmitter } from '../../../base/browser/event.js';
 import { Event } from '../../../base/common/event.js';
 import { StandardKeyboardEvent } from '../../../base/browser/keyboardEvent.js';
@@ -27,6 +27,20 @@ function getIconClass(iconPath) {
     }
     return iconClass;
 }
+function quickInputButtonToAction(button, id, run) {
+    let cssClasses = button.iconClass || getIconClass(button.iconPath);
+    if (button.alwaysVisible) {
+        cssClasses = cssClasses ? `${cssClasses} always-visible` : 'always-visible';
+    }
+    return {
+        id,
+        label: '',
+        tooltip: button.tooltip || '',
+        class: cssClasses,
+        enabled: true,
+        run
+    };
+}
 function renderQuickInputDescription(description, container, actionHandler) {
     reset(container);
     const parsed = parseLinkedText(description);
@@ -69,4 +83,4 @@ function renderQuickInputDescription(description, container, actionHandler) {
         }
     }
 }
-export { getIconClass, renderQuickInputDescription };
+export { quickInputButtonToAction, renderQuickInputDescription };

package/vscode/src/vs/platform/quickinput/common/quickInput.d.ts

@@ -77,10 +77,6 @@ interface IPickOptions<T extends IQuickPickItem> {
      * an optional flag to filter the picks based on label. Defaults to true.
      */
     matchOnLabel?: boolean;
-    /**
-     * an option flag to control whether focus is always automatically brought to a list item. Defaults to true.
-     */
-    autoFocusOnList?: boolean;
     /**
      * an optional flag to not close the picker on focus lost
      */
@@ -166,31 +162,81 @@ declare enum QuickInputHideReason {
 interface IQuickInputHideEvent {
     reason: QuickInputHideReason;
 }
+/**
+ * Represents a quick input control that allows users to make selections or provide input quickly.
+ */
 interface IQuickInput extends IDisposable {
+    /**
+     * An event that is fired when the quick input is hidden.
+     */
     readonly onDidHide: Event<IQuickInputHideEvent>;
+    /**
+     * An event that is fired when the quick input is disposed.
+     */
     readonly onDispose: Event<void>;
+    /**
+     * The title of the quick input.
+     */
     title: string | undefined;
+    /**
+     * The description of the quick input. This is rendered right below the input box.
+     */
     description: string | undefined;
     /**
-     * Should be an HTMLElement.
-     * @deprecated Use an IQuickWidget instead
+     * An HTML widget rendered below the input.
+     * @deprecated Use an IQuickWidget instead.
      */
     widget: any | undefined;
+    /**
+     * The current step of the quick input rendered in the titlebar.
+     */
     step: number | undefined;
+    /**
+     * The total number of steps in the quick input rendered in the titlebar.
+     */
     totalSteps: number | undefined;
+    /**
+     * The buttons displayed in the quick input titlebar.
+     */
     buttons: ReadonlyArray<IQuickInputButton>;
+    /**
+     * An event that is fired when a button in the quick input is triggered.
+     */
     readonly onDidTriggerButton: Event<IQuickInputButton>;
+    /**
+     * Indicates whether the input is enabled.
+     */
     enabled: boolean;
+    /**
+     * The context key associated with the quick input.
+     */
     contextKey: string | undefined;
+    /**
+     * Indicates whether the quick input is busy. Renders a progress bar if true.
+     */
     busy: boolean;
+    /**
+     * Indicates whether the quick input should be hidden when it loses focus.
+     */
     ignoreFocusOut: boolean;
+    /**
+     * Shows the quick input.
+     */
     show(): void;
+    /**
+     * Hides the quick input.
+     */
     hide(): void;
+    /**
+     * Notifies that the quick input has been hidden.
+     * @param reason The reason why the quick input was hidden.
+     */
     didHide(reason?: QuickInputHideReason): void;
 }
 interface IQuickWidget extends IQuickInput {
     /**
      * Should be an HTMLElement (TODO: move this entire file into browser)
+     * @override
      */
     widget: any | undefined;
 }
@@ -209,86 +255,206 @@ interface IQuickPickDidAcceptEvent {
      */
     inBackground: boolean;
 }
+/**
+ * Represents the activation behavior for items in a quick input. This means which item will be
+ * "active" (aka focused).
+ */
 declare enum ItemActivation {
+    /**
+     * No item will be active.
+     */
     NONE = 0,
+    /**
+     * First item will be active.
+     */
     FIRST = 1,
+    /**
+     * Second item will be active.
+     */
     SECOND = 2,
+    /**
+     * Last item will be active.
+     */
     LAST = 3
 }
+/**
+ * Represents a quick pick control that allows the user to select an item from a list of options.
+ */
 interface IQuickPick<T extends IQuickPickItem> extends IQuickInput {
+    /**
+     * The current value of the quick pick input.
+     */
     value: string;
     /**
-     * A method that allows to massage the value used
-     * for filtering, e.g, to remove certain parts.
+     * A method that allows to massage the value used for filtering, e.g, to remove certain parts.
+     * @param value The value to be filtered.
+     * @returns The filtered value.
      */
     filterValue: (value: string) => string;
+    /**
+     * The ARIA label for the quick pick input.
+     */
     ariaLabel: string | undefined;
+    /**
+     * The placeholder text for the quick pick input.
+     */
     placeholder: string | undefined;
+    /**
+     * An event that is fired when the value of the quick pick input changes.
+     */
     readonly onDidChangeValue: Event<string>;
+    /**
+     * An event that is fired when the quick pick is about to accept the selected item.
+     */
     readonly onWillAccept: Event<IQuickPickWillAcceptEvent>;
+    /**
+     * An event that is fired when the quick pick has accepted the selected item.
+     */
     readonly onDidAccept: Event<IQuickPickDidAcceptEvent>;
     /**
-     * If enabled, will fire the `onDidAccept` event when
-     * pressing the arrow-right key with the idea of accepting
-     * the selected item without closing the picker.
+     * If enabled, the `onDidAccept` event will be fired when pressing the arrow-right key to accept the selected item without closing the picker.
      */
     canAcceptInBackground: boolean;
+    /**
+     * The OK button state. It can be a boolean value or the string 'default'.
+     */
     ok: boolean | 'default';
+    /**
+     * An event that is fired when the custom button is triggered. The custom button is a button with text rendered to the right of the input.
+     */
     readonly onDidCustom: Event<void>;
+    /**
+     * Whether to show the custom button. The custom button is a button with text rendered to the right of the input.
+     */
     customButton: boolean;
+    /**
+     * The label for the custom button. The custom button is a button with text rendered to the right of the input.
+     */
     customLabel: string | undefined;
+    /**
+     * The hover text for the custom button. The custom button is a button with text rendered to the right of the input.
+     */
     customHover: string | undefined;
+    /**
+     * An event that is fired when an item button is triggered.
+     */
     readonly onDidTriggerItemButton: Event<IQuickPickItemButtonEvent<T>>;
+    /**
+     * An event that is fired when a separator button is triggered.
+     */
     readonly onDidTriggerSeparatorButton: Event<IQuickPickSeparatorButtonEvent>;
+    /**
+     * The items to be displayed in the quick pick.
+     */
     items: ReadonlyArray<T | IQuickPickSeparator>;
-    scrollTop: number;
+    /**
+     * Whether multiple items can be selected. If so, checkboxes will be rendered.
+     */
     canSelectMany: boolean;
+    /**
+     * Whether to match on the description of the items.
+     */
     matchOnDescription: boolean;
+    /**
+     * Whether to match on the detail of the items.
+     */
     matchOnDetail: boolean;
+    /**
+     * Whether to match on the label of the items.
+     */
     matchOnLabel: boolean;
     /**
-     * The mode to filter label with. Fuzzy will use fuzzy searching and
-     * contiguous will make filter entries that do not contain the exact string
-     * (including whitespace). This defaults to `'fuzzy'`.
+     * The mode to filter the label with. It can be 'fuzzy' or 'contiguous'. Defaults to 'fuzzy'.
      */
     matchOnLabelMode: 'fuzzy' | 'contiguous';
+    /**
+     * Whether to sort the items by label.
+     */
     sortByLabel: boolean;
-    autoFocusOnList: boolean;
+    /**
+     * Whether to keep the scroll position when the quick pick input is updated.
+     */
     keepScrollPosition: boolean;
+    /**
+     * The configuration for quick navigation.
+     */
     quickNavigate: IQuickNavigateConfiguration | undefined;
+    /**
+     * The currently active items.
+     */
     activeItems: ReadonlyArray<T>;
+    /**
+     * An event that is fired when the active items change.
+     */
     readonly onDidChangeActive: Event<T[]>;
     /**
-     * Allows to control which entry should be activated by default.
+     * The item activation behavior for the next time `items` is set. Item activation means which
+     * item is "active" (aka focused) when the quick pick is opened or when `items` is set.
      */
     itemActivation: ItemActivation;
+    /**
+     * The currently selected items.
+     */
     selectedItems: ReadonlyArray<T>;
+    /**
+     * An event that is fired when the selected items change.
+     */
     readonly onDidChangeSelection: Event<T[]>;
+    /**
+     * The key modifiers.
+     */
     readonly keyMods: IKeyMods;
+    /**
+     * The selection range for the value in the input.
+     */
     valueSelection: Readonly<[number, number]> | undefined;
+    /**
+     * The validation message for the quick pick. This is rendered below the input.
+     */
     validationMessage: string | undefined;
+    /**
+     * The severity of the validation message.
+     */
     severity: Severity;
+    /**
+     * Checks if the quick pick input has focus.
+     * @returns `true` if the quick pick input has focus, `false` otherwise.
+     */
     inputHasFocus(): boolean;
+    /**
+     * Focuses on the quick pick input.
+     */
     focusOnInput(): void;
     /**
-     * Hides the input box from the picker UI. This is typically used
-     * in combination with quick-navigation where no search UI should
-     * be presented.
+     * Hides the input box from the picker UI. This is typically used in combination with quick-navigation where no search UI should be presented.
      */
     hideInput: boolean;
     /**
-     * Allows to control if the count for the items should be shown
+     * Controls whether the count for the items should be shown.
      */
     hideCountBadge: boolean;
+    /**
+     * Whether to hide the "Check All" checkbox.
+     */
     hideCheckAll: boolean;
     /**
-     * A set of `Toggle` objects to add to the input box.
+     * The toggle buttons to be added to the input box.
      */
     toggles: IQuickInputToggle[] | undefined;
 }
+/**
+ * Represents a toggle for quick input.
+ */
 interface IQuickInputToggle {
+    /**
+     * Event that is fired when the toggle value changes.
+     * The boolean value indicates whether the change was triggered via keyboard.
+     */
     onChange: Event<boolean>;
 }
+/**
+ * Represents an input box in a quick input dialog.
+ */
 interface IInputBox extends IQuickInput {
     /**
      * Value shown in the input box.
@@ -328,30 +494,68 @@ interface IInputBox extends IQuickInput {
      */
     severity: Severity;
 }
+/**
+ * Represents a button in the quick input UI.
+ */
 interface IQuickInputButton {
-    /** iconPath or iconClass required */
+    /**
+     * The path to the icon for the button.
+     * Either `iconPath` or `iconClass` is required.
+     */
     iconPath?: {
         dark: URI;
         light?: URI;
     };
-    /** iconPath or iconClass required */
+    /**
+     * The CSS class for the icon of the button.
+     * Either `iconPath` or `iconClass` is required.
+     */
     iconClass?: string;
+    /**
+     * The tooltip text for the button.
+     */
     tooltip?: string;
     /**
-     * Whether to always show the button. By default buttons
-     * are only visible when hovering over them with the mouse
+     * Whether to always show the button.
+     * By default, buttons are only visible when hovering over them with the mouse.
      */
     alwaysVisible?: boolean;
 }
+/**
+ * Represents an event that occurs when a button associated with a quick pick item is clicked.
+ * @template T - The type of the quick pick item.
+ */
 interface IQuickPickItemButtonEvent<T extends IQuickPickItem> {
+    /**
+     * The button that was clicked.
+     */
     button: IQuickInputButton;
+    /**
+     * The quick pick item associated with the button.
+     */
     item: T;
 }
+/**
+ * Represents an event that occurs when a separator button is clicked in a quick pick.
+ */
 interface IQuickPickSeparatorButtonEvent {
+    /**
+     * The button that was clicked.
+     */
     button: IQuickInputButton;
+    /**
+     * The separator associated with the button.
+     */
     separator: IQuickPickSeparator;
 }
+/**
+ * Represents a context for a button associated with a quick pick item.
+ * @template T - The type of the quick pick item.
+ */
 interface IQuickPickItemButtonContext<T extends IQuickPickItem> extends IQuickPickItemButtonEvent<T> {
+    /**
+     * Removes the associated item from the quick pick.
+     */
     removeItem(): void;
 }
 type QuickPickInput<T = IQuickPickItem> = T | IQuickPickSeparator;

package/vscode/src/vs/platform/remote/common/remoteAuthorityResolver.d.ts

@@ -61,6 +61,7 @@ interface TunnelInformation {
         elevation: boolean;
         public?: boolean;
         privacyOptions: TunnelPrivacy[];
+        protocol: boolean;
     };
 }
 interface ResolverResult {

package/vscode/src/vs/platform/telemetry/common/telemetryUtils.js

@@ -106,6 +106,7 @@ function removePropertiesWithPossibleUserInfo(property) {
     const userDataRegexes = [
         { label: 'Google API Key', regex: /AIza[A-Za-z0-9_\\\-]{35}/ },
         { label: 'Slack Token', regex: /xox[pbar]\-[A-Za-z0-9]/ },
+        { label: 'GitHub Token', regex: /(gh[psuro]_[a-zA-Z0-9]{36}|github_pat_[a-zA-Z0-9]{22}_[a-zA-Z0-9]{59})/ },
         { label: 'Generic Secret', regex: /(key|token|sig|secret|signature|password|passwd|pwd|android:value)[^a-zA-Z0-9]/i },
         { label: 'Email', regex: /@[a-zA-Z0-9-]+\.[a-zA-Z0-9-]+/ }
     ];