@cmtlyt/lingshu-toolkit 0.4.0 → 0.6.0

package/dist/607.js

@@ -1,737 +0,0 @@
-import { throwType, createError, logger, $dt, throwError, getType, identity, dataHandler, $t, noop } from "./707.js";
-function isSymbol(_v) {
-    return 'symbol' == typeof _v;
-}
-function isUndef(_v) {
-    return void 0 === _v;
-}
-function isNull(_v) {
-    return null === _v;
-}
-function isNullOrUndef(_v) {
-    return isNull(_v) || isUndef(_v);
-}
-function verify_isNaN(_v) {
-    return Number.isNaN(_v);
-}
-function isPlainSymbol(_v) {
-    return isSymbol(_v) && isUndef(Symbol.keyFor(_v));
-}
-function isObject(_v) {
-    return 'object' == typeof _v && !isNull(_v);
-}
-function isPlainObject(_v) {
-    return isObject(_v) && !isArray(_v);
-}
-function isArray(_v) {
-    return Array.isArray(_v);
-}
-function isEmptyArray(_v) {
-    return isArray(_v) && 0 === _v.length;
-}
-function isString(_v) {
-    return 'string' == typeof _v;
-}
-function isEmptyString(_v) {
-    return isString(_v) && 0 === _v.length;
-}
-function isNumber(_v) {
-    return 'number' == typeof _v;
-}
-function isPlainNumber(_v) {
-    return isNumber(_v) && !verify_isNaN(_v);
-}
-function isPropertyKey(_v) {
-    return isString(_v) || isNumber(_v) || isSymbol(_v);
-}
-function isBoolean(_v) {
-    return 'boolean' == typeof _v;
-}
-function isTrue(_v) {
-    return true === _v || isString(_v) && 'true' === _v.toLowerCase();
-}
-function isFalse(_v) {
-    return false === _v || isString(_v) && 'false' === _v.toLowerCase();
-}
-function isTruthy(_v) {
-    return !!_v;
-}
-function isFalsy(_v) {
-    return !(verify_isNaN(_v) || _v);
-}
-function isFunction(_v) {
-    return 'function' == typeof _v;
-}
-function isPromiseLike(_v) {
-    return isObject(_v) && isFunction(_v.then);
-}
-function withResolvers() {
-    return 'function' == typeof Promise.withResolvers ? Promise.withResolvers() : (()=>{
-        const resolver = {
-            promise: null,
-            resolve: null,
-            reject: null
-        };
-        resolver.promise = new Promise((resolve, reject)=>{
-            resolver.resolve = resolve;
-            resolver.reject = reject;
-        });
-        return resolver;
-    })();
-}
-function detectCycle(from, to, waitingForGraph) {
-    const visited = new Set();
-    const queue = [
-        to
-    ];
-    let head = 0;
-    while(head < queue.length){
-        const node = queue[head++];
-        if (node === from) return true;
-        if (visited.has(node)) continue;
-        visited.add(node);
-        const deps = waitingForGraph.get(node);
-        if (deps) {
-            const depsIter = deps.values();
-            for(let dep = depsIter.next(); !dep.done; dep = depsIter.next())queue.push(dep.value);
-        }
-    }
-    return false;
-}
-function getCached(results, depName, allSettled) {
-    if (Reflect.getOwnPropertyDescriptor(results, depName)) {
-        const cached = results[depName];
-        if (allSettled) return 'rejected' === cached.status ? Promise.reject(cached.reason) : Promise.resolve(cached.value);
-        return Promise.resolve(cached);
-    }
-}
-function createDepResolver(waitingFor, resolverMap, currentTask, depName) {
-    waitingFor.set(currentTask, (waitingFor.get(currentTask) || new Set()).add(depName));
-    const depResolvers = resolverMap.get(depName) || withResolvers();
-    resolverMap.set(depName, depResolvers);
-    return depResolvers.promise.then((value)=>{
-        waitingFor.get(currentTask)?.delete(depName);
-        return value;
-    }, (error)=>{
-        waitingFor.get(currentTask)?.delete(depName);
-        throw error;
-    });
-}
-function cleanWaitingForGraph(waitingForGraph, depName) {
-    waitingForGraph.forEach((deps, task)=>{
-        deps.delete(depName);
-        if (0 === deps.size) waitingForGraph.delete(task);
-    });
-}
-function createDepProxy(tasks, results, options) {
-    const resolverMap = new Map();
-    const taskNameSet = new Set(Reflect.ownKeys(tasks));
-    const waitingForGraph = new Map();
-    const resolveDepFor = (depName, value)=>{
-        const resolver = resolverMap.get(depName);
-        if (resolver) {
-            resolver.resolve(value);
-            resolverMap.delete(depName);
-        }
-        cleanWaitingForGraph(waitingForGraph, depName);
-    };
-    const rejectDepFor = (depName, error)=>{
-        const resolver = resolverMap.get(depName);
-        if (resolver) {
-            resolver.reject(error);
-            resolverMap.delete(depName);
-        }
-        cleanWaitingForGraph(waitingForGraph, depName);
-    };
-    const createContextFor = (currentTask)=>new Proxy({}, {
-            get (_, depName) {
-                if (!taskNameSet.has(depName)) return Promise.reject(createError('allx', `Unknown task "${String(depName)}"`));
-                const cached = getCached(results, depName, options.allSettled);
-                if (cached) return cached;
-                if (detectCycle(currentTask, depName, waitingForGraph)) return Promise.reject(createError('allx', `Circular dependency detected: "${String(currentTask)}" -> "${String(depName)}"`));
-                return createDepResolver(waitingForGraph, resolverMap, currentTask, depName);
-            }
-        });
-    return {
-        taskNameSet,
-        createContextFor,
-        resolveDepFor,
-        rejectDepFor
-    };
-}
-function getValueFormatFunc(options) {
-    if (!options) return (value, _type = 'fulfilled')=>value;
-    if (options.allSettled) return (value, status = 'fulfilled')=>'fulfilled' === status ? {
-            status,
-            value
-        } : {
-            status,
-            reason: value
-        };
-    return (value, _type = 'fulfilled')=>value;
-}
-const validInfo = $dt({
-    allSettled: $t.boolean(false)
-});
-async function allx(tasks, options) {
-    const validOptions = dataHandler(options || {}, validInfo, {
-        unwrap: true
-    });
-    const { allSettled } = validOptions;
-    const results = {};
-    const depCtrl = createDepProxy(tasks, results, validOptions);
-    const valueFormat = getValueFormatFunc(options);
-    const promises = [];
-    depCtrl.taskNameSet.forEach(async (taskName)=>{
-        const taskFn = tasks[taskName];
-        const context = {
-            $: depCtrl.createContextFor(taskName)
-        };
-        const taskResolvers = withResolvers();
-        taskResolvers.promise.then((value)=>{
-            results[taskName] = valueFormat(value, 'fulfilled');
-            depCtrl.resolveDepFor(taskName, value);
-            return value;
-        }, (error)=>{
-            if (allSettled) results[taskName] = valueFormat(error, 'rejected');
-            depCtrl.rejectDepFor(taskName, error);
-        });
-        promises.push(taskResolvers.promise);
-        if (isPromiseLike(taskFn)) return void await taskFn.then(taskResolvers.resolve, taskResolvers.reject);
-        if (!isFunction(taskFn)) return void taskResolvers.resolve(taskFn);
-        try {
-            const result = await taskFn.call(context);
-            taskResolvers.resolve(result);
-        } catch (error) {
-            taskResolvers.reject(error);
-        }
-    });
-    if (allSettled) return Promise.allSettled(promises).then(()=>results);
-    return Promise.all(promises).then(()=>results);
-}
-function getNextValueHandler(from, to, valueFormatter) {
-    const type = getType(from);
-    const context = {
-        progress: 0,
-        valueFormatter
-    };
-    const baseNextValue = (_from, _to)=>{
-        const { valueFormatter: formatter, progress } = context;
-        if ('number' !== getType(_from)) return _from;
-        return formatter(_from + (_to - _from) * progress);
-    };
-    const arrayHandler = (_from, _to)=>{
-        const result = Array.from(_from, (item, idx)=>{
-            if (Array.isArray(item)) return arrayHandler(item, _to[idx]);
-            if ('object' === getType(item)) return objectHandler(item, _to[idx]);
-            return baseNextValue(item, _to[idx]);
-        });
-        return result;
-    };
-    const objectHandler = (_from, _to)=>{
-        const result = {};
-        const keys = Reflect.ownKeys(_from);
-        for(let i = 0; i < keys.length; i++){
-            const key = keys[i];
-            const fromValue = _from[key];
-            const toValue = _to[key];
-            if (Array.isArray(_from[key])) result[key] = arrayHandler(fromValue, toValue);
-            else if ('object' === getType(fromValue)) result[key] = objectHandler(fromValue, toValue);
-            else result[key] = baseNextValue(fromValue, toValue);
-        }
-        return result;
-    };
-    let nextValueHandler = baseNextValue;
-    if ('array' === type) nextValueHandler = arrayHandler;
-    else if ('object' === type) nextValueHandler = objectHandler;
-    return (progress)=>{
-        context.progress = progress;
-        return nextValueHandler(from, to);
-    };
-}
-function matchValid(from, to, valueParser) {
-    const fromType = getType(from);
-    const toType = getType(to);
-    if (fromType !== toType) throwType('animation/stepAnimation', 'from and to must be the same type');
-    if ('array' === fromType) {
-        if (from.length !== to.length) throwType('animation/stepAnimation', 'from and to must be the same length');
-        const result = [
-            Array.from({
-                length: from.length
-            }),
-            Array.from({
-                length: to.length
-            })
-        ];
-        for(let i = 0; i < from.length; i++){
-            const [fromItem, toItem] = matchValid(from[i], to[i], valueParser);
-            result[0][i] = fromItem;
-            result[1][i] = toItem;
-        }
-        return result;
-    }
-    if ('object' === fromType) {
-        const toKeys = Reflect.ownKeys(to);
-        const fromKeys = new Set(Reflect.ownKeys(from));
-        const result = [
-            {},
-            {}
-        ];
-        for(let i = 0; i < toKeys.length; i++){
-            const key = toKeys[i];
-            if (!fromKeys.has(key)) throwType('animation/stepAnimation', `from does not have this key: ${String(key)}`);
-            const [fromItem, toItem] = matchValid(from[key], to[key], valueParser);
-            result[0][key] = fromItem;
-            result[1][key] = toItem;
-        }
-        return result;
-    }
-    if ('number' !== fromType) return [
-        valueParser(from),
-        valueParser(to)
-    ];
-    return [
-        from,
-        to
-    ];
-}
-function createNextTick(resolvers, rcSignal) {
-    const nextTick = (()=>{
-        if ('function' == typeof globalThis.requestAnimationFrame) return globalThis.requestAnimationFrame;
-        return (callback)=>setTimeout(callback, 16);
-    })();
-    return (callback)=>{
-        if (rcSignal.stopSignal) return true;
-        nextTick(()=>tryRun(callback, resolvers, (error)=>{
-                rcSignal.stop();
-                resolvers.reject(error);
-            }));
-        return false;
-    };
-}
-async function tryRun(callback, resolvers, customErrorHandler) {
-    return new Promise((resolve, reject)=>{
-        const result = callback();
-        if (result && 'function' == typeof result.then) return result.then(resolve, reject);
-        resolve();
-    }).catch(customErrorHandler || resolvers.reject);
-}
-function createRunningControllerSignal(startFn, options) {
-    const { onStart, onStop, onClear } = options;
-    const resolvers = withResolvers();
-    const ctrl = {
-        stopSignal: true,
-        resolvers,
-        stop: ()=>{
-            ctrl.stopSignal = true;
-            onStop();
-        },
-        start: ()=>{
-            ctrl.stopSignal = false;
-            onStart();
-            startFn();
-        },
-        clear: ()=>{
-            ctrl.stopSignal = true;
-            onClear();
-            resolvers.resolve(true);
-        }
-    };
-    return ctrl;
-}
-const animation_validInfo = $dt({
-    autoStart: $t.boolean(true),
-    easing: $t["function"](()=>identity),
-    onStart: $t["function"](()=>noop),
-    onStop: $t["function"](()=>noop),
-    onClear: $t["function"](()=>noop),
-    onUpdate: $t["function"](()=>noop),
-    onComplete: $t["function"](()=>noop),
-    formatterValue: $t["function"](()=>identity),
-    formatter: $t["function"](()=>identity),
-    parser: $t["function"](()=>identity)
-});
-function* stepAnimation(from, to, step, options = {}) {
-    if (!Number.isInteger(step) || step <= 0) throwError('stepAnimation', 'step must be a positive integer', RangeError);
-    const validOptions = dataHandler(options, animation_validInfo, {
-        unwrap: true
-    });
-    const { parser: valueParser = identity, formatterValue = identity, formatter } = validOptions;
-    const [validFrom, validTo] = matchValid(from, to, valueParser);
-    const getNextValue = getNextValueHandler(validFrom, validTo, formatterValue);
-    for(let i = 0; i <= step; i++){
-        const value = formatter(getNextValue(i / step));
-        yield value;
-    }
-}
-function animation(from, to, duration, options = {}) {
-    if (duration <= 0 || !Number.isInteger(duration)) throwError('animation', 'duration must be a positive integer', RangeError);
-    const validOptions = dataHandler(options, animation_validInfo, {
-        unwrap: true
-    });
-    const [validFrom, validTo] = matchValid(from, to, validOptions.parser);
-    const { autoStart, easing, onComplete, onUpdate, formatterValue, formatter } = validOptions;
-    const _getNextValue = getNextValueHandler(validFrom, validTo, formatterValue);
-    const getNextValue = (...args)=>formatter(_getNextValue(...args));
-    let startTime = 0;
-    let hasStarted = false;
-    const rcSignal = createRunningControllerSignal(()=>{
-        const now = performance.now();
-        startTime += now;
-        const stopFlag = nextTick(tick);
-        if (stopFlag) {
-            startTime -= performance.now();
-            return;
-        }
-        if (!hasStarted) {
-            onUpdate(getNextValue(0));
-            hasStarted = true;
-        }
-    }, validOptions);
-    const { resolvers } = rcSignal;
-    const nextTick = createNextTick(resolvers, rcSignal);
-    const tick = ()=>{
-        const elapsed = performance.now() - startTime;
-        const progress = easing(Math.min(elapsed / duration, 1));
-        const value = getNextValue(progress);
-        onUpdate(value);
-        if (elapsed < duration) {
-            const stopFlag = nextTick(tick);
-            if (stopFlag) startTime = -elapsed;
-        } else {
-            onComplete();
-            resolvers.resolve(false);
-        }
-    };
-    if (false !== autoStart) rcSignal.start();
-    return {
-        promise: resolvers.promise,
-        stop: rcSignal.stop,
-        start: rcSignal.start,
-        clear: rcSignal.clear
-    };
-}
-function getEmpty(_v) {
-    return Array.isArray(_v) ? [] : {};
-}
-function valueCheck(_v) {
-    return Array.isArray(_v) || 'object' == typeof _v;
-}
-function conditionMerge(...input) {
-    const conditionItems = (input.length > 1 ? input : input[0]).map((item)=>{
-        let result = null;
-        if (Array.isArray(item)) {
-            const [condition, value, fullback] = item;
-            result = {
-                condition,
-                value,
-                fullback
-            };
-        } else if (Object.getOwnPropertyDescriptor(item, 'condition')) result = item;
-        else throwType('conditionMerge', 'input must be an ConditionItem');
-        const validValue = valueCheck(result.value);
-        const validFullback = void 0 === result.fullback || valueCheck(result.fullback);
-        if (!(validValue && validFullback)) throwType('conditionMerge', 'value and fullback must be an array or object');
-        return result;
-    });
-    const result = getEmpty(conditionItems[0].value);
-    const mergeFn = Array.isArray(result) ? (a1, a2)=>Reflect.apply(Array.prototype.splice.bind(a1, a1.length, 0), null, a2) : Object.assign;
-    for(let i = 0, item = conditionItems[i]; i < conditionItems.length; item = conditionItems[++i])mergeFn(result, item.condition ? item.value : item.fullback || getEmpty(item.value));
-    return result;
-}
-const create_storage_handler_validInfo = $dt({
-    storageKey: 'validString',
-    storageType: $t["enum"]([
-        'local',
-        'session',
-        'memory'
-    ], 'local'),
-    autoSaveInterval: $t.number(0)
-});
-const memoryStorage = {
-    data: {},
-    getItem (key) {
-        return this.data[key];
-    },
-    setItem (key, value) {
-        this.data[key] = value;
-    },
-    removeItem (key) {
-        delete this.data[key];
-    }
-};
-function getStorage(storageType) {
-    try {
-        if ('memory' === storageType) return memoryStorage;
-        return 'local' === storageType ? localStorage : sessionStorage;
-    } catch  {
-        logger.warn('createStorage', 'Failed to access localStorage or sessionStorage, using memoryStorage instead.');
-        return memoryStorage;
-    }
-}
-const CLEAR_FLAG = Symbol('cleared');
-function createStorageHandler(storageKey, initialData, options = {}) {
-    const { storageKey: validStorageKey, storageType, autoSaveInterval } = dataHandler({
-        storageKey,
-        ...options
-    }, create_storage_handler_validInfo, {
-        unwrap: true
-    });
-    const storage = getStorage(storageType);
-    const storageData = storage.getItem(validStorageKey);
-    const context = {
-        data: storageData ? JSON.parse(storageData) : initialData || {}
-    };
-    return {
-        get (key) {
-            if (context.data === CLEAR_FLAG) throwError('createStorageHandler', 'Storage has been cleared.');
-            if (null == key) return context.data;
-            return context.data[key];
-        },
-        set (value, key) {
-            if (context.data === CLEAR_FLAG) throwError('createStorageHandler', 'Storage has been cleared.');
-            if (null == key) context.data = value;
-            else context.data[key] = value;
-            if (autoSaveInterval > 0) setTimeout(()=>{
-                storage.setItem(validStorageKey, JSON.stringify(context.data));
-            }, autoSaveInterval);
-            else storage.setItem(validStorageKey, JSON.stringify(context.data));
-        },
-        clear () {
-            context.data = CLEAR_FLAG;
-            storage.removeItem(validStorageKey);
-        }
-    };
-}
-const SLOT_TYPE = {
-    fixed: {
-        fixedFlag: Symbol('fixed')
-    },
-    insert: {
-        insertFlag: Symbol('insert')
-    }
-};
-const data_mixed_manager_validInfo = $dt({
-    name: $t.string('default'),
-    fixedSlots: $t.array([]),
-    dataList: $t.array([]),
-    listener: $t.object({})
-});
-class DataMixedManager extends EventTarget {
-    addEventListener(...args) {
-        return super.addEventListener.apply(this, args);
-    }
-    removeEventListener(...args) {
-        return super.removeEventListener.apply(this, args);
-    }
-    options;
-    fixedSlots = new Map();
-    dataList = [];
-    mixedData = [];
-    lastMixedSlotIdx = -1;
-    prevDataLength = 0;
-    isBatching = false;
-    constructor(options){
-        super();
-        const validOptions = dataHandler(options || {}, data_mixed_manager_validInfo, {
-            unwrap: true
-        });
-        const { fixedSlots, dataList, listener } = validOptions;
-        this.options = validOptions;
-        this.addFixedSlots(fixedSlots, {
-            lazy: true
-        });
-        this.appendList(dataList);
-        try {
-            this.initListener(listener);
-        } catch (error) {
-            throwError('dataMixedManager', error.message, error.constructor);
-        }
-    }
-    initListener(listener) {
-        const listenerNames = Object.keys(listener);
-        for(let i = 0, name = listenerNames[i], handler = listener[name]; i < listenerNames.length; name = listenerNames[++i], handler = listener[name])this.addEventListener(name, handler);
-    }
-    getTypeText(_type) {
-        switch(_type){
-            case SLOT_TYPE.fixed:
-                return 'fixed';
-            case SLOT_TYPE.insert:
-                return 'insert';
-        }
-    }
-    buildSlotConfig(config, type) {
-        const typeText = this.getTypeText(config.type || type);
-        return {
-            ...config,
-            type: typeText,
-            inputPosition: config.position,
-            insertMode: config.insertMode || 'cover'
-        };
-    }
-    addFixedSlot(config, buildOptions) {
-        const realConfig = this.reorderFixedSlots(this.buildSlotConfig(config, SLOT_TYPE.fixed));
-        this.fixedSlots.set(realConfig.position, realConfig);
-        this.buildMixedData(buildOptions);
-        return realConfig.position;
-    }
-    reorderFixedSlots(config) {
-        const { position: oldPosition, insertMode } = config;
-        if (null == insertMode || 'cover' === insertMode || !this.fixedSlots.has(oldPosition)) return {
-            ...config,
-            inputPosition: oldPosition
-        };
-        const position = 'after' === insertMode ? oldPosition + 1 : oldPosition;
-        for(let i = position + 1, preItem = this.fixedSlots.get(i - 1), currItem = this.fixedSlots.get(i); preItem; ++i, preItem = currItem, currItem = this.fixedSlots.get(i)){
-            preItem.position = i;
-            this.fixedSlots.set(i, preItem);
-        }
-        return {
-            ...config,
-            position,
-            inputPosition: oldPosition
-        };
-    }
-    addFixedSlots(configs, buildOptions) {
-        if (!configs.length) return [];
-        const positions = this.batchUpdate(()=>configs.map((config)=>this.addFixedSlot(config)));
-        this.buildMixedData(buildOptions);
-        return positions;
-    }
-    deleteFixedSlot(position, buildOptions) {
-        this.fixedSlots.delete(position);
-        this.buildMixedData(buildOptions);
-    }
-    deleteFixedSlots(positions, buildOptions) {
-        if (!positions.length) return;
-        this.batchUpdate(()=>positions.forEach((position)=>void this.deleteFixedSlot(position)));
-        this.buildMixedData(buildOptions);
-    }
-    batchUpdate(callback) {
-        try {
-            this.isBatching = true;
-            const result = callback();
-            return result;
-        } finally{
-            this.isBatching = false;
-        }
-    }
-    clearFixedSlots(buildOptions) {
-        this.fixedSlots.clear();
-        this.buildMixedData(buildOptions);
-    }
-    appendList(list, buildOptions) {
-        if (!list.length) return;
-        this.dataList.push(...list);
-        this.buildMixedData({
-            ...buildOptions,
-            lazy: true === (buildOptions || {}).lazy
-        });
-    }
-    clearList() {
-        this.dataList.length = 0;
-        this.mixedData.length = 0;
-        this.dispatch('change', {
-            mode: 'clear',
-            mixedData: this.getMixedData({
-                mode: 'rebuild'
-            })
-        });
-        this.dispatch('clear');
-    }
-    getMixedData(buildOptions) {
-        this.buildMixedData({
-            ...buildOptions,
-            lazy: false
-        });
-        return this.mixedData.slice();
-    }
-    dispatch(name, data) {
-        const detail = {
-            name: this.options.name,
-            ...data
-        };
-        this.dispatchEvent(new CustomEvent(name, {
-            detail
-        }));
-        if ("u" > typeof window) window.dispatchEvent(new CustomEvent(`[DMM]:${name}`, {
-            detail
-        }));
-    }
-    buildMixedData(buildOptions) {
-        if (this.isBatching) return;
-        const { lazy, mode } = buildOptions || {};
-        if ('rebuild' === mode) {
-            this.prevDataLength = 0;
-            this.lastMixedSlotIdx = -1;
-        }
-        if (false !== lazy || this.dataList.length <= this.prevDataLength) return;
-        let dataStartIdx = this.prevDataLength;
-        const dataEndIdx = this.dataList.length;
-        const newItemCount = dataEndIdx - dataStartIdx;
-        this.prevDataLength = dataEndIdx;
-        const isPatchMode = dataStartIdx > 0;
-        const filteredSlots = this.sliceSlots(isPatchMode ? this.mixedData.length : this.lastMixedSlotIdx, this.mixedData.length + newItemCount);
-        this.lastMixedSlotIdx = filteredSlots.at(-1) ?? this.lastMixedSlotIdx;
-        let mixedStartIdx = isPatchMode ? this.mixedData.length : 0;
-        this.mixedData.length = (isPatchMode ? newItemCount + mixedStartIdx : dataEndIdx) + filteredSlots.length;
-        for(let fpIdx = 0, fpItem = filteredSlots[fpIdx]; dataStartIdx < dataEndIdx; ++mixedStartIdx)if (mixedStartIdx === fpItem) {
-            const fixedSlot = this.fixedSlots.get(fpItem);
-            this.mixedData[mixedStartIdx] = {
-                isFixed: true,
-                type: fixedSlot.type,
-                data: fixedSlot.data
-            };
-            fpItem = filteredSlots[++fpIdx];
-        } else {
-            this.mixedData[mixedStartIdx] = {
-                isFixed: false,
-                type: 'plain',
-                data: this.dataList[dataStartIdx]
-            };
-            ++dataStartIdx;
-        }
-        this.dispatch('change', {
-            mode: isPatchMode ? 'patch' : 'rebuild',
-            mixedData: this.mixedData.slice()
-        });
-    }
-    sliceSlots(startIdx, endIdx = 1 / 0) {
-        let prevItem = -2;
-        let count = 0;
-        return Array.from(this.fixedSlots.keys()).sort((ai, bi)=>ai - bi).filter((item)=>{
-            if (item >= startIdx && item < endIdx + count || item - 1 === prevItem) {
-                ++count;
-                prevItem = item;
-                return true;
-            }
-            return false;
-        });
-    }
-    insertSlot(config) {
-        const realPosition = this.addFixedSlot({
-            ...config,
-            type: SLOT_TYPE.insert
-        });
-        if (realPosition > this.mixedData.length) return realPosition;
-        this.buildMixedData({
-            lazy: false,
-            mode: 'rebuild'
-        });
-        return realPosition;
-    }
-    insertSlots(configs) {
-        if (!configs.length) return [];
-        const positions = this.batchUpdate(()=>configs.map((config)=>this.insertSlot(config)));
-        this.buildMixedData({
-            lazy: false,
-            mode: 'rebuild'
-        });
-        return positions;
-    }
-}
-function dataMixedManager(options) {
-    return new DataMixedManager(options);
-}
-Symbol('__PACK__');
-export { allx, animation, conditionMerge, createStorageHandler, dataMixedManager, isArray, isBoolean, isEmptyArray, isEmptyString, isFalse, isFalsy, isFunction, isNull, isNullOrUndef, isNumber, isObject, isPlainNumber, isPlainObject, isPlainSymbol, isPromiseLike, isPropertyKey, isString, isSymbol, isTrue, isTruthy, isUndef, stepAnimation, verify_isNaN as isNaN, withResolvers };