@xiuchang-midscene/shared 2.0.2

package/dist/es/utils.mjs

@@ -0,0 +1,72 @@
+import { sha256 } from "js-sha256";
+import { v4 } from "uuid";
+const ifInBrowser = 'undefined' != typeof window;
+const ifInWorker = 'undefined' != typeof WorkerGlobalScope;
+const ifInNode = 'undefined' != typeof process && process.versions?.node;
+function uuid() {
+    return v4();
+}
+const hashMap = {};
+function generateHashId(rect, content = '') {
+    const combined = JSON.stringify({
+        content,
+        rect
+    });
+    let sliceLength = 5;
+    let slicedHash = '';
+    const hashHex = sha256.create().update(combined).hex();
+    const toLetters = (hex)=>hex.split('').map((char)=>{
+            const code = Number.parseInt(char, 16);
+            return String.fromCharCode(97 + code % 26);
+        }).join('');
+    const hashLetters = toLetters(hashHex);
+    while(sliceLength < hashLetters.length - 1){
+        slicedHash = hashLetters.slice(0, sliceLength);
+        if (hashMap[slicedHash] && hashMap[slicedHash] !== combined) {
+            sliceLength++;
+            continue;
+        }
+        hashMap[slicedHash] = combined;
+        break;
+    }
+    return slicedHash;
+}
+function assert(condition, message) {
+    if (!condition) throw new Error(message || 'Assertion failed');
+}
+let isMcp = false;
+function setIsMcp(value) {
+    isMcp = value;
+}
+function logMsg(...message) {
+    if (!isMcp) console.log(...message);
+}
+async function repeat(times, fn) {
+    for(let i = 0; i < times; i++)await fn(i);
+}
+const utils_REGEXP_LT = /</g;
+const utils_REGEXP_GT = />/g;
+const REGEXP_LT_ESCAPE = '__midscene_lt__';
+const REGEXP_GT_ESCAPE = '__midscene_gt__';
+const escapeScriptTag = (html)=>html.replace(utils_REGEXP_LT, REGEXP_LT_ESCAPE).replace(utils_REGEXP_GT, REGEXP_GT_ESCAPE);
+const antiEscapeScriptTag = (html)=>{
+    const REGEXP_LT = new RegExp(REGEXP_LT_ESCAPE, 'g');
+    const REGEXP_GT = new RegExp(REGEXP_GT_ESCAPE, 'g');
+    return html.replace(REGEXP_LT, '<').replace(REGEXP_GT, '>');
+};
+function replaceIllegalPathCharsAndSpace(str) {
+    return str.replace(/[:*?"<>|# ]/g, '-');
+}
+function isPlainObject(value) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value);
+}
+function normalizeForComparison(str) {
+    return str.toLowerCase().replace(/[\s\-_]+/g, '');
+}
+function mergeAndNormalizeAppNameMapping(defaultMapping, userMapping) {
+    const result = {};
+    for (const [key, value] of Object.entries(defaultMapping))result[normalizeForComparison(key)] = value;
+    if (userMapping) for (const [key, value] of Object.entries(userMapping))result[normalizeForComparison(key)] = value;
+    return result;
+}
+export { antiEscapeScriptTag, assert, escapeScriptTag, generateHashId, ifInBrowser, ifInNode, ifInWorker, isPlainObject, logMsg, mergeAndNormalizeAppNameMapping, normalizeForComparison, repeat, replaceIllegalPathCharsAndSpace, setIsMcp, uuid };

package/dist/es/utils.mjs.bak

@@ -0,0 +1,72 @@
+import { sha256 } from "js-sha256";
+import { v4 } from "uuid";
+const ifInBrowser = 'undefined' != typeof window;
+const ifInWorker = 'undefined' != typeof WorkerGlobalScope;
+const ifInNode = 'undefined' != typeof process && process.versions?.node;
+function uuid() {
+    return v4();
+}
+const hashMap = {};
+function generateHashId(rect, content = '') {
+    const combined = JSON.stringify({
+        content,
+        rect
+    });
+    let sliceLength = 5;
+    let slicedHash = '';
+    const hashHex = sha256.create().update(combined).hex();
+    const toLetters = (hex)=>hex.split('').map((char)=>{
+            const code = Number.parseInt(char, 16);
+            return String.fromCharCode(97 + code % 26);
+        }).join('');
+    const hashLetters = toLetters(hashHex);
+    while(sliceLength < hashLetters.length - 1){
+        slicedHash = hashLetters.slice(0, sliceLength);
+        if (hashMap[slicedHash] && hashMap[slicedHash] !== combined) {
+            sliceLength++;
+            continue;
+        }
+        hashMap[slicedHash] = combined;
+        break;
+    }
+    return slicedHash;
+}
+function assert(condition, message) {
+    if (!condition) throw new Error(message || 'Assertion failed');
+}
+let isMcp = false;
+function setIsMcp(value) {
+    isMcp = value;
+}
+function logMsg(...message) {
+    if (!isMcp) console.log(...message);
+}
+async function repeat(times, fn) {
+    for(let i = 0; i < times; i++)await fn(i);
+}
+const utils_REGEXP_LT = /</g;
+const utils_REGEXP_GT = />/g;
+const REGEXP_LT_ESCAPE = '__midscene_lt__';
+const REGEXP_GT_ESCAPE = '__midscene_gt__';
+const escapeScriptTag = (html)=>html.replace(utils_REGEXP_LT, REGEXP_LT_ESCAPE).replace(utils_REGEXP_GT, REGEXP_GT_ESCAPE);
+const antiEscapeScriptTag = (html)=>{
+    const REGEXP_LT = new RegExp(REGEXP_LT_ESCAPE, 'g');
+    const REGEXP_GT = new RegExp(REGEXP_GT_ESCAPE, 'g');
+    return html.replace(REGEXP_LT, '<').replace(REGEXP_GT, '>');
+};
+function replaceIllegalPathCharsAndSpace(str) {
+    return str.replace(/[:*?"<>|# ]/g, '-');
+}
+function isPlainObject(value) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value);
+}
+function normalizeForComparison(str) {
+    return str.toLowerCase().replace(/[\s\-_]+/g, '');
+}
+function mergeAndNormalizeAppNameMapping(defaultMapping, userMapping) {
+    const result = {};
+    for (const [key, value] of Object.entries(defaultMapping))result[normalizeForComparison(key)] = value;
+    if (userMapping) for (const [key, value] of Object.entries(userMapping))result[normalizeForComparison(key)] = value;
+    return result;
+}
+export { antiEscapeScriptTag, assert, escapeScriptTag, generateHashId, ifInBrowser, ifInNode, ifInWorker, isPlainObject, logMsg, mergeAndNormalizeAppNameMapping, normalizeForComparison, repeat, replaceIllegalPathCharsAndSpace, setIsMcp, uuid };

package/dist/es/zod-schema-utils.mjs

@@ -0,0 +1,54 @@
+function unwrapZodField(field) {
+    const f = field;
+    if (!f._def) return f;
+    const typeName = f._def.typeName;
+    if ('ZodOptional' === typeName || 'ZodNullable' === typeName || 'ZodDefault' === typeName) return unwrapZodField(f._def.innerType);
+    if ('ZodEffects' === typeName) {
+        if (f._def.schema) return unwrapZodField(f._def.schema);
+    }
+    return f;
+}
+function isMidsceneLocatorField(field) {
+    const actualField = unwrapZodField(field);
+    if (actualField._def?.typeName === 'ZodObject') {
+        const shape = actualField._def.shape?.();
+        if (shape) {
+            if ('midscene_location_field_flag' in shape) return true;
+            if ('prompt' in shape && shape.prompt) return true;
+        }
+    }
+    return false;
+}
+function getZodTypeName(field, locatorTypeDescription) {
+    const actualField = unwrapZodField(field);
+    const fieldTypeName = actualField._def?.typeName;
+    if ('ZodString' === fieldTypeName) return 'string';
+    if ('ZodNumber' === fieldTypeName) return 'number';
+    if ('ZodBoolean' === fieldTypeName) return 'boolean';
+    if ('ZodArray' === fieldTypeName) return 'array';
+    if ('ZodObject' === fieldTypeName) {
+        if (isMidsceneLocatorField(actualField)) return locatorTypeDescription || 'object';
+        return 'object';
+    }
+    if ('ZodEnum' === fieldTypeName) {
+        const values = actualField._def?.values?.map((option)=>String(`'${option}'`)).join(', ') ?? 'enum';
+        return `enum(${values})`;
+    }
+    if ('ZodUnion' === fieldTypeName) {
+        const options = actualField._def?.options;
+        if (options && options.length > 0) {
+            const types = options.map((opt)=>getZodTypeName(opt, locatorTypeDescription));
+            return types.join(' | ');
+        }
+        return 'union';
+    }
+    return 'unknown';
+}
+function getZodDescription(field) {
+    if ("description" in field) return field.description || null;
+    const actualField = unwrapZodField(field);
+    if ("description" in actualField) return actualField.description || null;
+    if (isMidsceneLocatorField(actualField)) return 'Location information for the target element';
+    return null;
+}
+export { getZodDescription, getZodTypeName, isMidsceneLocatorField, unwrapZodField };

package/dist/es/zod-schema-utils.mjs.bak

@@ -0,0 +1,54 @@
+function unwrapZodField(field) {
+    const f = field;
+    if (!f._def) return f;
+    const typeName = f._def.typeName;
+    if ('ZodOptional' === typeName || 'ZodNullable' === typeName || 'ZodDefault' === typeName) return unwrapZodField(f._def.innerType);
+    if ('ZodEffects' === typeName) {
+        if (f._def.schema) return unwrapZodField(f._def.schema);
+    }
+    return f;
+}
+function isMidsceneLocatorField(field) {
+    const actualField = unwrapZodField(field);
+    if (actualField._def?.typeName === 'ZodObject') {
+        const shape = actualField._def.shape?.();
+        if (shape) {
+            if ('midscene_location_field_flag' in shape) return true;
+            if ('prompt' in shape && shape.prompt) return true;
+        }
+    }
+    return false;
+}
+function getZodTypeName(field, locatorTypeDescription) {
+    const actualField = unwrapZodField(field);
+    const fieldTypeName = actualField._def?.typeName;
+    if ('ZodString' === fieldTypeName) return 'string';
+    if ('ZodNumber' === fieldTypeName) return 'number';
+    if ('ZodBoolean' === fieldTypeName) return 'boolean';
+    if ('ZodArray' === fieldTypeName) return 'array';
+    if ('ZodObject' === fieldTypeName) {
+        if (isMidsceneLocatorField(actualField)) return locatorTypeDescription || 'object';
+        return 'object';
+    }
+    if ('ZodEnum' === fieldTypeName) {
+        const values = actualField._def?.values?.map((option)=>String(`'${option}'`)).join(', ') ?? 'enum';
+        return `enum(${values})`;
+    }
+    if ('ZodUnion' === fieldTypeName) {
+        const options = actualField._def?.options;
+        if (options && options.length > 0) {
+            const types = options.map((opt)=>getZodTypeName(opt, locatorTypeDescription));
+            return types.join(' | ');
+        }
+        return 'union';
+    }
+    return 'unknown';
+}
+function getZodDescription(field) {
+    if ("description" in field) return field.description || null;
+    const actualField = unwrapZodField(field);
+    if ("description" in actualField) return actualField.description || null;
+    if (isMidsceneLocatorField(actualField)) return 'Location information for the target element';
+    return null;
+}
+export { getZodDescription, getZodTypeName, isMidsceneLocatorField, unwrapZodField };

package/dist/lib/baseDB.js

@@ -0,0 +1,149 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    IndexedDBManager: ()=>IndexedDBManager,
+    createCleanupFunction: ()=>createCleanupFunction,
+    withErrorHandling: ()=>withErrorHandling
+});
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class IndexedDBManager {
+    initDB() {
+        return new Promise((resolve, reject)=>{
+            const request = indexedDB.open(this.dbName, this.version);
+            request.onerror = ()=>reject(request.error);
+            request.onsuccess = ()=>resolve(request.result);
+            request.onupgradeneeded = (event)=>{
+                const db = event.target.result;
+                this.storeConfigs.forEach(({ name, keyPath })=>{
+                    if (!db.objectStoreNames.contains(name)) {
+                        const store = db.createObjectStore(name, {
+                            keyPath
+                        });
+                        store.createIndex('timestamp', 'timestamp', {
+                            unique: false
+                        });
+                    }
+                });
+            };
+        });
+    }
+    async withTransaction(storeNames, mode, operation) {
+        const db = await this.dbPromise;
+        const transaction = db.transaction(storeNames, mode);
+        const stores = Array.isArray(storeNames) ? storeNames.map((name)=>transaction.objectStore(name)) : transaction.objectStore(storeNames);
+        return operation(stores);
+    }
+    promisifyRequest(request) {
+        return new Promise((resolve, reject)=>{
+            request.onsuccess = ()=>resolve(request.result);
+            request.onerror = ()=>reject(request.error);
+        });
+    }
+    async put(storeName, data) {
+        await this.withTransaction(storeName, 'readwrite', async (store)=>{
+            await this.promisifyRequest(store.put(data));
+        });
+    }
+    async get(storeName, key) {
+        return this.withTransaction(storeName, 'readonly', async (store)=>this.promisifyRequest(store.get(key)));
+    }
+    async getAll(storeName, sortByTimestamp = true) {
+        return this.withTransaction(storeName, 'readonly', async (store)=>{
+            const objectStore = store;
+            const results = sortByTimestamp ? await this.promisifyRequest(objectStore.index('timestamp').getAll()) : await this.promisifyRequest(objectStore.getAll());
+            return sortByTimestamp ? results.sort((a, b)=>a.timestamp - b.timestamp) : results;
+        });
+    }
+    async clear(storeName) {
+        await this.withTransaction(storeName, 'readwrite', async (store)=>{
+            await this.promisifyRequest(store.clear());
+        });
+    }
+    async delete(storeName, key) {
+        await this.withTransaction(storeName, 'readwrite', async (store)=>{
+            await this.promisifyRequest(store.delete(key));
+        });
+    }
+    async count(storeName) {
+        return this.withTransaction(storeName, 'readonly', async (store)=>this.promisifyRequest(store.count()));
+    }
+    getDBPromise() {
+        return this.dbPromise;
+    }
+    constructor(dbName, version, storeConfigs){
+        _define_property(this, "dbPromise", void 0);
+        _define_property(this, "dbName", void 0);
+        _define_property(this, "version", void 0);
+        _define_property(this, "storeConfigs", void 0);
+        this.dbName = dbName;
+        this.version = version;
+        this.storeConfigs = storeConfigs;
+        this.dbPromise = this.initDB();
+    }
+}
+const withErrorHandling = async (operation, errorMessage, defaultValue, onQuotaExceeded)=>{
+    try {
+        return await operation();
+    } catch (e) {
+        console.error(errorMessage, e);
+        if (e instanceof Error && 'QuotaExceededError' === e.name && onQuotaExceeded) {
+            console.log('Storage quota exceeded, running cleanup...');
+            await onQuotaExceeded();
+        }
+        return defaultValue;
+    }
+};
+const createCleanupFunction = (dbManager, storeName, maxItems)=>async ()=>{
+        try {
+            const results = await dbManager.getAll(storeName);
+            if (results.length > maxItems) {
+                const toDelete = results.sort((a, b)=>a.timestamp - b.timestamp).slice(0, results.length - maxItems);
+                await Promise.all(toDelete.map((item)=>dbManager.delete(storeName, item.id)));
+            }
+        } catch (e) {
+            console.error(`Failed to cleanup ${storeName}:`, e);
+        }
+    };
+exports.IndexedDBManager = __webpack_exports__.IndexedDBManager;
+exports.createCleanupFunction = __webpack_exports__.createCleanupFunction;
+exports.withErrorHandling = __webpack_exports__.withErrorHandling;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "IndexedDBManager",
+    "createCleanupFunction",
+    "withErrorHandling"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/baseDB.js.bak

@@ -0,0 +1,149 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    IndexedDBManager: ()=>IndexedDBManager,
+    createCleanupFunction: ()=>createCleanupFunction,
+    withErrorHandling: ()=>withErrorHandling
+});
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class IndexedDBManager {
+    initDB() {
+        return new Promise((resolve, reject)=>{
+            const request = indexedDB.open(this.dbName, this.version);
+            request.onerror = ()=>reject(request.error);
+            request.onsuccess = ()=>resolve(request.result);
+            request.onupgradeneeded = (event)=>{
+                const db = event.target.result;
+                this.storeConfigs.forEach(({ name, keyPath })=>{
+                    if (!db.objectStoreNames.contains(name)) {
+                        const store = db.createObjectStore(name, {
+                            keyPath
+                        });
+                        store.createIndex('timestamp', 'timestamp', {
+                            unique: false
+                        });
+                    }
+                });
+            };
+        });
+    }
+    async withTransaction(storeNames, mode, operation) {
+        const db = await this.dbPromise;
+        const transaction = db.transaction(storeNames, mode);
+        const stores = Array.isArray(storeNames) ? storeNames.map((name)=>transaction.objectStore(name)) : transaction.objectStore(storeNames);
+        return operation(stores);
+    }
+    promisifyRequest(request) {
+        return new Promise((resolve, reject)=>{
+            request.onsuccess = ()=>resolve(request.result);
+            request.onerror = ()=>reject(request.error);
+        });
+    }
+    async put(storeName, data) {
+        await this.withTransaction(storeName, 'readwrite', async (store)=>{
+            await this.promisifyRequest(store.put(data));
+        });
+    }
+    async get(storeName, key) {
+        return this.withTransaction(storeName, 'readonly', async (store)=>this.promisifyRequest(store.get(key)));
+    }
+    async getAll(storeName, sortByTimestamp = true) {
+        return this.withTransaction(storeName, 'readonly', async (store)=>{
+            const objectStore = store;
+            const results = sortByTimestamp ? await this.promisifyRequest(objectStore.index('timestamp').getAll()) : await this.promisifyRequest(objectStore.getAll());
+            return sortByTimestamp ? results.sort((a, b)=>a.timestamp - b.timestamp) : results;
+        });
+    }
+    async clear(storeName) {
+        await this.withTransaction(storeName, 'readwrite', async (store)=>{
+            await this.promisifyRequest(store.clear());
+        });
+    }
+    async delete(storeName, key) {
+        await this.withTransaction(storeName, 'readwrite', async (store)=>{
+            await this.promisifyRequest(store.delete(key));
+        });
+    }
+    async count(storeName) {
+        return this.withTransaction(storeName, 'readonly', async (store)=>this.promisifyRequest(store.count()));
+    }
+    getDBPromise() {
+        return this.dbPromise;
+    }
+    constructor(dbName, version, storeConfigs){
+        _define_property(this, "dbPromise", void 0);
+        _define_property(this, "dbName", void 0);
+        _define_property(this, "version", void 0);
+        _define_property(this, "storeConfigs", void 0);
+        this.dbName = dbName;
+        this.version = version;
+        this.storeConfigs = storeConfigs;
+        this.dbPromise = this.initDB();
+    }
+}
+const withErrorHandling = async (operation, errorMessage, defaultValue, onQuotaExceeded)=>{
+    try {
+        return await operation();
+    } catch (e) {
+        console.error(errorMessage, e);
+        if (e instanceof Error && 'QuotaExceededError' === e.name && onQuotaExceeded) {
+            console.log('Storage quota exceeded, running cleanup...');
+            await onQuotaExceeded();
+        }
+        return defaultValue;
+    }
+};
+const createCleanupFunction = (dbManager, storeName, maxItems)=>async ()=>{
+        try {
+            const results = await dbManager.getAll(storeName);
+            if (results.length > maxItems) {
+                const toDelete = results.sort((a, b)=>a.timestamp - b.timestamp).slice(0, results.length - maxItems);
+                await Promise.all(toDelete.map((item)=>dbManager.delete(storeName, item.id)));
+            }
+        } catch (e) {
+            console.error(`Failed to cleanup ${storeName}:`, e);
+        }
+    };
+exports.IndexedDBManager = __webpack_exports__.IndexedDBManager;
+exports.createCleanupFunction = __webpack_exports__.createCleanupFunction;
+exports.withErrorHandling = __webpack_exports__.withErrorHandling;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "IndexedDBManager",
+    "createCleanupFunction",
+    "withErrorHandling"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/build/copy-static.js

@@ -0,0 +1,79 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createCopyStaticPlugin: ()=>createCopyStaticPlugin,
+    createPlaygroundCopyPlugin: ()=>createPlaygroundCopyPlugin
+});
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const createCopyStaticPlugin = (options)=>({
+        name: options.pluginName || 'copy-static',
+        setup (api) {
+            api.onAfterBuild(async ()=>{
+                const { srcDir, destDir, faviconPath } = options;
+                const stat = await external_node_fs_default().promises.lstat(destDir).catch(()=>null);
+                if (stat?.isSymbolicLink()) await external_node_fs_default().promises.unlink(destDir);
+                await external_node_fs_default().promises.mkdir(destDir, {
+                    recursive: true
+                });
+                await external_node_fs_default().promises.cp(srcDir, destDir, {
+                    recursive: true
+                });
+                console.log(`Copied build artifacts from ${srcDir} to ${destDir}`);
+                if (faviconPath) {
+                    const faviconDest = external_node_path_default().join(destDir, 'favicon.ico');
+                    await external_node_fs_default().promises.copyFile(faviconPath, faviconDest);
+                    console.log(`Copied favicon from ${faviconPath} to ${faviconDest}`);
+                }
+            });
+        }
+    });
+const createPlaygroundCopyPlugin = (srcDir, destDir, pluginName, faviconSrc)=>createCopyStaticPlugin({
+        srcDir,
+        destDir,
+        faviconPath: faviconSrc,
+        pluginName
+    });
+exports.createCopyStaticPlugin = __webpack_exports__.createCopyStaticPlugin;
+exports.createPlaygroundCopyPlugin = __webpack_exports__.createPlaygroundCopyPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createCopyStaticPlugin",
+    "createPlaygroundCopyPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});