@ckeditor/ckeditor5-list 47.6.1 → 48.0.0-alpha.0

package/src/listformatting/listitemitalicintegration.js

@@ -1,88 +0,0 @@
-/**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
-/**
- * @module list/listformatting/listitemitalicintegration
- */
-import { Plugin } from 'ckeditor5/src/core.js';
-import { env } from 'ckeditor5/src/utils.js';
-import { ListEditing } from '../list/listediting.js';
-/**
- * The list item italic integration plugin.
- */
-export class ListItemItalicIntegration extends Plugin {
-    /**
-     * @inheritDoc
-     */
-    static get pluginName() {
-        return 'ListItemItalicIntegration';
-    }
-    /**
-     * @inheritDoc
-     */
-    static get isOfficialPlugin() {
-        return true;
-    }
-    /**
-     * @inheritDoc
-     */
-    static get requires() {
-        return [ListEditing];
-    }
-    /**
-     * @inheritDoc
-     */
-    init() {
-        const editor = this.editor;
-        const ListFormatting = editor.plugins.get('ListFormatting');
-        const listEditing = editor.plugins.get(ListEditing);
-        if (!editor.plugins.has('ItalicEditing') || !this.editor.config.get('list.enableListItemMarkerFormatting')) {
-            return;
-        }
-        ListFormatting.registerFormatAttribute('italic', 'listItemItalic');
-        // Register the downcast strategy in init() so that the attribute name is registered before the list editing
-        // registers its converters.
-        // This ensures that the attribute is recognized by downcast strategies and bogus paragraphs are handled correctly.
-        listEditing.registerDowncastStrategy({
-            scope: 'item',
-            attributeName: 'listItemItalic',
-            setAttributeOnDowncast(writer, value, viewElement, options) {
-                if (value) {
-                    writer.addClass('ck-list-marker-italic', viewElement);
-                    // See: https://github.com/ckeditor/ckeditor5/issues/18790.
-                    if (env.isSafari && !(options && options.dataPipeline)) {
-                        writer.setStyle('--ck-content-list-marker-dummy-italic', '0', viewElement);
-                    }
-                }
-            }
-        });
-    }
-    /**
-     * @inheritDoc
-     */
-    afterInit() {
-        const editor = this.editor;
-        const model = editor.model;
-        if (!editor.plugins.has('ItalicEditing') || !this.editor.config.get('list.enableListItemMarkerFormatting')) {
-            return;
-        }
-        model.schema.extend('$listItem', { allowAttributes: 'listItemItalic' });
-        model.schema.setAttributeProperties('listItemItalic', {
-            isFormatting: true
-        });
-        model.schema.addAttributeCheck(context => {
-            const item = context.last;
-            if (!item.getAttribute('listItemId')) {
-                return false;
-            }
-        }, 'listItemItalic');
-        editor.conversion.for('upcast').attributeToAttribute({
-            model: 'listItemItalic',
-            view: {
-                name: 'li',
-                classes: 'ck-list-marker-italic'
-            }
-        });
-    }
-}

package/src/listformatting.js

@@ -1,248 +0,0 @@
-/**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
-/**
- * @module list/listformatting
- */
-import { Plugin } from 'ckeditor5/src/core.js';
-import { ListItemBoldIntegration } from './listformatting/listitemboldintegration.js';
-import { ListItemItalicIntegration } from './listformatting/listitemitalicintegration.js';
-import { ListItemFontSizeIntegration } from './listformatting/listitemfontsizeintegration.js';
-import { ListItemFontColorIntegration } from './listformatting/listitemfontcolorintegration.js';
-import { ListItemFontFamilyIntegration } from './listformatting/listitemfontfamilyintegration.js';
-import { isListItemBlock, getAllListItemBlocks, isFirstBlockOfListItem } from './list/utils/model.js';
-import '../theme/listformatting.css';
-/**
- * The list formatting plugin.
- *
- * It enables integration with formatting plugins to style the list marker.
- * The list marker is styled based on the consistent formatting applied to the content of the list item.
- *
- * The list of supported formatting plugins includes:
- * * Font color.
- * * Font size.
- * * Font family.
- * * Bold.
- * * Italic.
- */
-export class ListFormatting extends Plugin {
-    /**
-     * The list of loaded formatting.
-     */
-    _loadedFormatting = {};
-    /**
-     * @inheritDoc
-     */
-    static get pluginName() {
-        return 'ListFormatting';
-    }
-    /**
-     * @inheritDoc
-     */
-    static get isOfficialPlugin() {
-        return true;
-    }
-    /**
-     * @inheritDoc
-     */
-    static get requires() {
-        return [
-            ListItemBoldIntegration,
-            ListItemItalicIntegration,
-            ListItemFontSizeIntegration,
-            ListItemFontColorIntegration,
-            ListItemFontFamilyIntegration
-        ];
-    }
-    /**
-     * @inheritDoc
-     */
-    constructor(editor) {
-        super(editor);
-        editor.config.define('list.enableListItemMarkerFormatting', true);
-    }
-    /**
-     * @inheritDoc
-     */
-    afterInit() {
-        if (!this.editor.config.get('list.enableListItemMarkerFormatting')) {
-            return;
-        }
-        this._registerPostfixerForListItemFormatting();
-    }
-    /**
-     * Registers a postfixer that ensures that the list item formatting attribute is consistent with the formatting
-     * applied to the content of the list item.
-     */
-    _registerPostfixerForListItemFormatting() {
-        const model = this.editor.model;
-        model.document.registerPostFixer(writer => {
-            const changes = model.document.differ.getChanges();
-            const modifiedListItems = new Set();
-            let returnValue = false;
-            for (const entry of changes) {
-                if (entry.type === 'attribute') {
-                    if (entry.attributeKey == 'listItemId' ||
-                        entry.attributeKey == 'listType' ||
-                        this._isInlineOrSelectionFormatting(entry.attributeKey) ||
-                        Object.values(this._loadedFormatting).includes(entry.attributeKey)) {
-                        if (isListItemBlock(entry.range.start.nodeAfter)) {
-                            modifiedListItems.add(entry.range.start.nodeAfter);
-                        }
-                        else if (isListItemBlock(entry.range.start.parent)) {
-                            modifiedListItems.add(entry.range.start.parent);
-                        }
-                    }
-                }
-                else {
-                    if (isListItemBlock(entry.position.nodeAfter)) {
-                        modifiedListItems.add(entry.position.nodeAfter);
-                    }
-                    if (isListItemBlock(entry.position.nodeBefore)) {
-                        modifiedListItems.add(entry.position.nodeBefore);
-                    }
-                    if (isListItemBlock(entry.position.parent)) {
-                        modifiedListItems.add(entry.position.parent);
-                    }
-                    if (entry.type == 'insert' && entry.name != '$text') {
-                        const range = writer.createRangeIn(entry.position.nodeAfter);
-                        for (const item of range.getItems()) {
-                            if (isListItemBlock(item)) {
-                                modifiedListItems.add(item);
-                            }
-                        }
-                    }
-                }
-            }
-            for (const listItem of modifiedListItems) {
-                const formats = getListItemConsistentFormat(model, listItem, Object.keys(this._loadedFormatting));
-                for (const [formatAttributeName, formatValue] of Object.entries(formats)) {
-                    const listItemFormatAttributeName = this._loadedFormatting[formatAttributeName];
-                    if (formatValue && setFormattingToListItem(writer, listItem, listItemFormatAttributeName, formatValue)) {
-                        returnValue = true;
-                    }
-                    else if (!formatValue && removeFormattingFromListItem(writer, listItem, listItemFormatAttributeName)) {
-                        returnValue = true;
-                    }
-                }
-            }
-            return returnValue;
-        });
-    }
-    /**
-     * Registers an integration between a default attribute (e.g., `fontFamily`) and a new attribute
-     * intended specifically for list item elements (e.g., `listItemFontFamily`).
-     *
-     * These attributes are later used by the postfixer logic to determine whether to add the new attribute
-     * to the list item element, based on whether there is a consistent default formatting attribute
-     * applied within its content.
-     */
-    registerFormatAttribute(formatAttribute, listItemFormatAttribute) {
-        this._loadedFormatting[formatAttribute] = listItemFormatAttribute;
-    }
-    /**
-     * Returns true if the given model attribute name is a supported inline formatting attribute.
-     */
-    _isInlineOrSelectionFormatting(attributeKey) {
-        return attributeKey.replace(/^selection:/, '') in this._loadedFormatting;
-    }
-}
-/**
- * Returns the consistent format of the list item element.
- * If the list item contains multiple blocks, it checks only the first block.
- */
-function getListItemConsistentFormat(model, listItem, attributeKeys) {
-    if (isFirstBlockOfListItem(listItem)) {
-        return getSingleListItemConsistentFormat(model, listItem, attributeKeys);
-    }
-    // Always the first block of the list item should be checked for consistent formatting.
-    const listItemBlocks = getAllListItemBlocks(listItem);
-    return getSingleListItemConsistentFormat(model, listItemBlocks[0], attributeKeys);
-}
-/**
- * Returns the consistent format of a single list item element.
- */
-function getSingleListItemConsistentFormat(model, listItem, attributeKeys) {
-    // Only bulleted and numbered lists can have formatting (to-do lists are not supported).
-    // Do not check internals of limit elements (for example, do not check table cells).
-    if (!isNumberedOrBulletedList(listItem) || model.schema.isLimit(listItem)) {
-        return Object.fromEntries(attributeKeys.map(attributeKey => [attributeKey]));
-    }
-    if (listItem.isEmpty) {
-        return Object.fromEntries(attributeKeys.map(attributeKey => ([attributeKey, listItem.getAttribute(`selection:${attributeKey}`)])));
-    }
-    const attributesToCheck = new Set(attributeKeys);
-    const valuesMap = {};
-    const range = model.createRangeIn(listItem);
-    const walker = range.getWalker({ ignoreElementEnd: true });
-    for (const { item } of walker) {
-        for (const attributeKey of attributesToCheck) {
-            if (model.schema.checkAttribute(item, attributeKey)) {
-                const formatAttribute = item.getAttribute(attributeKey);
-                if (formatAttribute === undefined) {
-                    attributesToCheck.delete(attributeKey);
-                    valuesMap[attributeKey] = undefined;
-                }
-                else if (valuesMap[attributeKey] === undefined) {
-                    // First item inside a list item block.
-                    valuesMap[attributeKey] = formatAttribute;
-                }
-                else if (valuesMap[attributeKey] !== formatAttribute) {
-                    // Following items in the same block of a list item.
-                    attributesToCheck.delete(attributeKey);
-                    valuesMap[attributeKey] = undefined;
-                }
-            }
-            else if (!(attributeKey in valuesMap)) {
-                // Store it so a format would be removed when all items in the given list item does not allow that formatting.
-                valuesMap[attributeKey] = undefined;
-            }
-        }
-        // End early if all attributes have been checked and are inconsistent.
-        if (!attributesToCheck.size) {
-            break;
-        }
-        // Jump over inline limit elements as we expect only outside them to be the same formatting.
-        if (model.schema.isLimit(item)) {
-            walker.jumpTo(model.createPositionAfter(item));
-        }
-    }
-    return valuesMap;
-}
-/**
- * Adds the specified formatting attribute to the list item element.
- */
-function setFormattingToListItem(writer, listItem, attributeKey, attributeValue) {
-    // Multi-block items should have consistent formatting.
-    const listItemBlocks = getAllListItemBlocks(listItem);
-    let wasChanged = false;
-    for (const listItem of listItemBlocks) {
-        if (!listItem.hasAttribute(attributeKey) || listItem.getAttribute(attributeKey) !== attributeValue) {
-            writer.setAttribute(attributeKey, attributeValue, listItem);
-            wasChanged = true;
-        }
-    }
-    return wasChanged;
-}
-/**
- * Removes the specified formatting attribute from the list item element.
- */
-function removeFormattingFromListItem(writer, listItem, attributeKey) {
-    // Multi-block items should have consistent formatting.
-    const listItemBlocks = getAllListItemBlocks(listItem);
-    let wasChanged = false;
-    for (const listItem of listItemBlocks) {
-        if (listItem.hasAttribute(attributeKey)) {
-            writer.removeAttribute(attributeKey, listItem);
-            wasChanged = true;
-        }
-    }
-    return wasChanged;
-}
-/**
- * Checks if the given list type is a numbered or bulleted list.
- */
-function isNumberedOrBulletedList(listItem) {
-    return ['numbered', 'bulleted', 'customNumbered', 'customBulleted'].includes(listItem.getAttribute('listType'));
-}

package/src/listproperties/converters.js

@@ -1,43 +0,0 @@
-/**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
-/**
- * Returns a converter that consumes the `style`, `reversed`, and `start` attributes.
- * In `style`, it searches for the `list-style-type` definition.
- * If not found, the `"default"` value will be used.
- *
- * @internal
- * @param strategy
- */
-export function listPropertiesUpcastConverter(strategy) {
-    return (evt, data, conversionApi) => {
-        const { writer, schema, consumable } = conversionApi;
-        // If there is no view consumable to consume, set the default attribute value to be able to reconvert nested lists on parent change.
-        // So abort converting if attribute was directly consumed.
-        if (consumable.test(data.viewItem, strategy.viewConsumables) === false) {
-            return;
-        }
-        if (!data.modelRange) {
-            Object.assign(data, conversionApi.convertChildren(data.viewItem, data.modelCursor));
-        }
-        let applied = false;
-        for (const item of data.modelRange.getItems({ shallow: true })) {
-            if (!schema.checkAttribute(item, strategy.attributeName)) {
-                continue;
-            }
-            if (!strategy.appliesToListItem(item)) {
-                continue;
-            }
-            // Set list attributes only on same level items, those nested deeper are already handled by the recursive conversion.
-            if (item.hasAttribute(strategy.attributeName)) {
-                continue;
-            }
-            writer.setAttribute(strategy.attributeName, strategy.getAttributeOnUpcast(data.viewItem), item);
-            applied = true;
-        }
-        if (applied) {
-            consumable.consume(data.viewItem, strategy.viewConsumables);
-        }
-    };
-}

package/src/listproperties/listpropertiesediting.js

@@ -1,291 +0,0 @@
-/**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
-/**
- * @module list/listproperties/listpropertiesediting
- */
-import { Plugin } from 'ckeditor5/src/core.js';
-import { ListEditing } from '../list/listediting.js';
-import { ListStartCommand } from './liststartcommand.js';
-import { ListStyleCommand } from './liststylecommand.js';
-import { ListReversedCommand } from './listreversedcommand.js';
-import { listPropertiesUpcastConverter } from './converters.js';
-import { getAllSupportedStyleTypes, getListTypeFromListStyleType, getListStyleTypeFromTypeAttribute, getTypeAttributeFromListStyleType, normalizeListStyle } from './utils/style.js';
-import { ListPropertiesUtils } from './listpropertiesutils.js';
-import { isNumberedListType } from '../list/utils/model.js';
-import { getNormalizedConfig } from './utils/config.js';
-const DEFAULT_LIST_TYPE = 'default';
-/**
- * The document list properties engine feature.
- *
- * It registers the `'listStyle'`, `'listReversed'` and `'listStart'` commands if they are enabled in the configuration.
- * Read more in {@link module:list/listconfig~ListPropertiesConfig}.
- */
-export class ListPropertiesEditing extends Plugin {
-    /**
-     * @inheritDoc
-     */
-    static get requires() {
-        return [ListEditing, ListPropertiesUtils];
-    }
-    /**
-     * @inheritDoc
-     */
-    static get pluginName() {
-        return 'ListPropertiesEditing';
-    }
-    /**
-     * @inheritDoc
-     * @internal
-     */
-    static get licenseFeatureCode() {
-        return 'LP';
-    }
-    /**
-     * @inheritDoc
-     */
-    static get isOfficialPlugin() {
-        return true;
-    }
-    /**
-     * @inheritDoc
-     */
-    static get isPremiumPlugin() {
-        return true;
-    }
-    /**
-     * @inheritDoc
-     */
-    constructor(editor) {
-        super(editor);
-        editor.config.define('list.properties', {
-            styles: true,
-            startIndex: false,
-            reversed: false
-        });
-    }
-    /**
-     * @inheritDoc
-     */
-    init() {
-        const editor = this.editor;
-        const model = editor.model;
-        const listEditing = editor.plugins.get(ListEditing);
-        const enabledProperties = editor.config.get('list.properties');
-        const strategies = createAttributeStrategies(enabledProperties);
-        for (const strategy of strategies) {
-            strategy.addCommand(editor);
-            model.schema.extend('$listItem', { allowAttributes: strategy.attributeName });
-            // Register downcast strategy.
-            listEditing.registerDowncastStrategy({
-                scope: 'list',
-                attributeName: strategy.attributeName,
-                setAttributeOnDowncast(writer, attributeValue, viewElement) {
-                    strategy.setAttributeOnDowncast(writer, attributeValue, viewElement);
-                }
-            });
-        }
-        // Set up conversion.
-        editor.conversion.for('upcast').add(dispatcher => {
-            for (const strategy of strategies) {
-                dispatcher.on('element:ol', listPropertiesUpcastConverter(strategy));
-                dispatcher.on('element:ul', listPropertiesUpcastConverter(strategy));
-            }
-        });
-        // Verify if the list view element (ul or ol) requires refreshing.
-        listEditing.on('checkAttributes:list', (evt, { viewElement, modelAttributes, modelReferenceElement }) => {
-            for (const strategy of strategies) {
-                if (!strategy.appliesToListItem(modelReferenceElement)) {
-                    continue;
-                }
-                if (strategy.getAttributeOnUpcast(viewElement) != modelAttributes[strategy.attributeName]) {
-                    evt.return = true;
-                    evt.stop();
-                }
-            }
-        });
-        // Reset list properties after indenting list items.
-        this.listenTo(editor.commands.get('indentList'), 'afterExecute', (evt, changedBlocks) => {
-            model.change(writer => {
-                for (const node of changedBlocks) {
-                    for (const strategy of strategies) {
-                        if (strategy.appliesToListItem(node)) {
-                            // Just reset the attribute.
-                            // If there is a previous indented list that this node should be merged into,
-                            // the postfixer will unify all the attributes of both sub-lists.
-                            writer.setAttribute(strategy.attributeName, strategy.defaultValue, node);
-                        }
-                    }
-                }
-            });
-        });
-        // Add or remove list properties attributes depending on the list type.
-        listEditing.on('postFixer', (evt, { listNodes, writer }) => {
-            for (const { node } of listNodes) {
-                for (const strategy of strategies) {
-                    // Check if attribute is valid.
-                    if (strategy.hasValidAttribute(node)) {
-                        continue;
-                    }
-                    // Add missing default property attributes...
-                    if (strategy.appliesToListItem(node)) {
-                        writer.setAttribute(strategy.attributeName, strategy.defaultValue, node);
-                    }
-                    // ...or remove invalid property attributes.
-                    else {
-                        writer.removeAttribute(strategy.attributeName, node);
-                    }
-                    evt.return = true;
-                }
-            }
-        });
-        // Make sure that all items in a single list (items at the same level & listType) have the same properties.
-        listEditing.on('postFixer', (evt, { listNodes, writer }) => {
-            for (const { node, previousNodeInList } of listNodes) {
-                // This is a first item of a nested list.
-                if (!previousNodeInList) {
-                    continue;
-                }
-                // This is a first block of a list of a different type.
-                if (previousNodeInList.getAttribute('listType') != node.getAttribute('listType')) {
-                    continue;
-                }
-                // Copy properties from the previous one.
-                for (const strategy of strategies) {
-                    const { attributeName } = strategy;
-                    if (!strategy.appliesToListItem(node)) {
-                        continue;
-                    }
-                    const value = previousNodeInList.getAttribute(attributeName);
-                    if (node.getAttribute(attributeName) != value) {
-                        writer.setAttribute(attributeName, value, node);
-                        evt.return = true;
-                    }
-                }
-            }
-        });
-    }
-}
-/**
- * Creates an array of strategies for dealing with enabled listItem attributes.
- */
-function createAttributeStrategies(enabledProperties) {
-    const strategies = [];
-    const normalizedConfig = getNormalizedConfig(enabledProperties);
-    if (enabledProperties.styles) {
-        const useAttribute = normalizedConfig.styles.useAttribute;
-        strategies.push({
-            attributeName: 'listStyle',
-            defaultValue: DEFAULT_LIST_TYPE,
-            viewConsumables: { styles: 'list-style-type' },
-            addCommand(editor) {
-                let supportedTypes = getAllSupportedStyleTypes();
-                if (useAttribute) {
-                    supportedTypes = supportedTypes.filter(styleType => !!getTypeAttributeFromListStyleType(styleType));
-                }
-                editor.commands.add('listStyle', new ListStyleCommand(editor, DEFAULT_LIST_TYPE, supportedTypes));
-            },
-            appliesToListItem(item) {
-                return item.getAttribute('listType') == 'numbered' || item.getAttribute('listType') == 'bulleted';
-            },
-            hasValidAttribute(item) {
-                if (!this.appliesToListItem(item)) {
-                    return !item.hasAttribute('listStyle');
-                }
-                if (!item.hasAttribute('listStyle')) {
-                    return false;
-                }
-                const value = item.getAttribute('listStyle');
-                if (value == DEFAULT_LIST_TYPE) {
-                    return true;
-                }
-                return getListTypeFromListStyleType(value) == item.getAttribute('listType');
-            },
-            setAttributeOnDowncast(writer, listStyle, element) {
-                if (listStyle && listStyle !== DEFAULT_LIST_TYPE) {
-                    if (useAttribute) {
-                        const value = getTypeAttributeFromListStyleType(listStyle);
-                        if (value) {
-                            writer.setAttribute('type', value, element);
-                            return;
-                        }
-                    }
-                    else {
-                        writer.setStyle('list-style-type', listStyle, element);
-                        return;
-                    }
-                }
-                writer.removeStyle('list-style-type', element);
-                writer.removeAttribute('type', element);
-            },
-            getAttributeOnUpcast(listParent) {
-                const style = listParent.getStyle('list-style-type');
-                if (style) {
-                    return normalizeListStyle(style);
-                }
-                const attribute = listParent.getAttribute('type');
-                if (attribute) {
-                    return getListStyleTypeFromTypeAttribute(attribute);
-                }
-                return DEFAULT_LIST_TYPE;
-            }
-        });
-    }
-    if (enabledProperties.reversed) {
-        strategies.push({
-            attributeName: 'listReversed',
-            defaultValue: false,
-            viewConsumables: { attributes: 'reversed' },
-            addCommand(editor) {
-                editor.commands.add('listReversed', new ListReversedCommand(editor));
-            },
-            appliesToListItem(item) {
-                return item.getAttribute('listType') == 'numbered';
-            },
-            hasValidAttribute(item) {
-                return this.appliesToListItem(item) == item.hasAttribute('listReversed');
-            },
-            setAttributeOnDowncast(writer, listReversed, element) {
-                if (listReversed) {
-                    writer.setAttribute('reversed', 'reversed', element);
-                }
-                else {
-                    writer.removeAttribute('reversed', element);
-                }
-            },
-            getAttributeOnUpcast(listParent) {
-                return listParent.hasAttribute('reversed');
-            }
-        });
-    }
-    if (enabledProperties.startIndex) {
-        strategies.push({
-            attributeName: 'listStart',
-            defaultValue: 1,
-            viewConsumables: { attributes: 'start' },
-            addCommand(editor) {
-                editor.commands.add('listStart', new ListStartCommand(editor));
-            },
-            appliesToListItem(item) {
-                return isNumberedListType(item.getAttribute('listType'));
-            },
-            hasValidAttribute(item) {
-                return this.appliesToListItem(item) == item.hasAttribute('listStart');
-            },
-            setAttributeOnDowncast(writer, listStart, element) {
-                if (listStart == 0 || listStart > 1) {
-                    writer.setAttribute('start', listStart, element);
-                }
-                else {
-                    writer.removeAttribute('start', element);
-                }
-            },
-            getAttributeOnUpcast(listParent) {
-                const startAttributeValue = listParent.getAttribute('start');
-                return startAttributeValue >= 0 ? startAttributeValue : 1;
-            }
-        });
-    }
-    return strategies;
-}