@rspack-debug/test-tools 1.4.11 → 1.6.4

package/dist/helper/legacy/warmup-webpack.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/helper/legacy/warmup-webpack.js

@@ -1,26 +0,0 @@
-"use strict";
-// @ts-nocheck
-describe("warmup", () => {
-    it("should warmup webpack", done => {
-        let webpack = require("@rspack/core");
-        const END = new Error("end warmup");
-        webpack({
-            entry: "data:text/javascript,import 'data:text/javascript,'",
-            plugins: [
-                c => c.hooks.emit.tap("Warmup", () => {
-                    throw END;
-                })
-            ]
-        }, err => {
-            webpack = undefined;
-            try {
-                // CHANGE: rspack will format error into diagnostic.
-                expect(err.message).toContain("end warmup");
-                done();
-            }
-            catch (e) {
-                done(e);
-            }
-        });
-    }, 300000);
-});

package/dist/helper/loaders/hot-update.d.ts

@@ -1 +0,0 @@
-export default function (this: any, c: string): string;

package/dist/helper/loaders/hot-update.js

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = default_1;
-function default_1(c) {
-    let content = c;
-    if (content.includes("NEXT_HMR")) {
-        content = `
-			${content}
-			let __hmr_children__ = [...module.children];
-      let __hmr_used_exports__ = __hmr_children__.reduce((res, child) => {
-        if (__webpack_module_cache__[child]) {
-          res[child] = __webpack_module_cache__[child].exports;
-        }
-				return res;
-			}, {});
-			module.hot.accept(__hmr_children__, () => {
-				__hmr_children__.forEach((child) => {
-					const reexports = __webpack_require__(child);
-          for (let key in reexports) {
-            if (!__hmr_used_exports__[child]) { continue; }
-						Object.defineProperty(__hmr_used_exports__[child], key, {
-							configurable: true,
-							enumerable: true,
-							get: () => reexports[key]
-						});
-					}
-				});
-			});
-		`;
-    }
-    content = content.replace(/NEXT_HMR/g, "NEXT_HMR.bind(null, module)");
-    const options = this.getOptions();
-    const items = content.split(/---+\r?\n/g);
-    if (items.length <= 1) {
-        return content;
-    }
-    options.totalUpdates = Math.max(options.totalUpdates, items.length);
-    options.changedFiles.push(this.resourcePath);
-    return items[options.updateIndex];
-}

package/dist/helper/plugins/hot-update.d.ts

@@ -1,7 +0,0 @@
-import type { Compiler } from "@rspack/core";
-import type { TUpdateOptions } from "../../type";
-export declare class TestHotUpdatePlugin {
-    private updateOptions;
-    constructor(updateOptions: TUpdateOptions);
-    apply(compiler: Compiler): void;
-}

package/dist/helper/plugins/hot-update.js

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TestHotUpdatePlugin = void 0;
-class TestHotUpdatePlugin {
-    constructor(updateOptions) {
-        this.updateOptions = updateOptions;
-    }
-    apply(compiler) {
-        let isRebuild = false;
-        compiler.hooks.beforeRun.tap("TestHotUpdatePlugin", () => {
-            if (isRebuild) {
-                compiler.modifiedFiles = new Set(this.updateOptions.changedFiles);
-            }
-            else {
-                compiler.modifiedFiles = new Set();
-            }
-            this.updateOptions.changedFiles = [];
-            isRebuild = true;
-        });
-        compiler.hooks.compilation.tap("TestHotUpdatePlugin", compilation => {
-            compilation.hooks.additionalTreeRuntimeRequirements.tap("HMR_TEST_PLUGIN", (_chunk, set) => {
-                set.add(compiler.webpack.RuntimeGlobals.moduleCache);
-            });
-            compilation.hooks.runtimeModule.tap("HMR_TEST_PLUGIN", (module, _set) => {
-                if (module.constructorName === "DefinePropertyGettersRuntimeModule") {
-                    module.source.source = Buffer.from(`
-										__webpack_require__.d = function (exports, definition) {
-												for (var key in definition) {
-														if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
-																Object.defineProperty(exports, key, { configurable: true, enumerable: true, get: definition[key] });
-														}
-												}
-										};
-										`, "utf-8");
-                }
-            });
-        });
-    }
-}
-exports.TestHotUpdatePlugin = TestHotUpdatePlugin;

package/dist/helper/plugins/index.d.ts

@@ -1 +0,0 @@
-export * from "./hot-update";

package/dist/helper/plugins/index.js

@@ -1,17 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./hot-update"), exports);

package/dist/helper/util/currentWatchStep.d.ts

@@ -1 +0,0 @@
-export const step: {};

package/dist/helper/util/currentWatchStep.js

@@ -1,2 +0,0 @@
-"use strict";
-exports.step = {};

package/dist/helper/util/identifier.d.ts

@@ -1,76 +0,0 @@
-/**
- * @param {string} context context used to create relative path
- * @param {string} identifier identifier used to create relative path
- * @param {Object=} associatedObjectForCache an object to which the cache will be attached
- * @returns {string} the returned relative path
- */
-export function makePathsRelative(context: string, identifier: string, associatedObjectForCache?: Object | undefined): string;
-export namespace makePathsRelative {
-    /**
-     * @param {Object=} associatedObjectForCache an object to which the cache will be attached
-     * @returns {function(string, string): string} cached function
-     */
-    function bindCache(associatedObjectForCache?: Object | undefined): (arg0: string, arg1: string) => string;
-    /**
-     * @param {string} context context used to create relative path
-     * @param {Object=} associatedObjectForCache an object to which the cache will be attached
-     * @returns {function(string): string} cached function
-     */
-    function bindContextCache(context: string, associatedObjectForCache?: Object | undefined): (arg0: string) => string;
-}
-/**
- * @param {string} context context used to create relative path
- * @param {string} identifier identifier used to create relative path
- * @param {Object=} associatedObjectForCache an object to which the cache will be attached
- * @returns {string} the returned relative path
- */
-export function makePathsRelative(context: string, identifier: string, associatedObjectForCache?: Object | undefined): string;
-export namespace makePathsRelative { }
-/**
- * @param {string} str the path with query and fragment
- * @param {Object=} associatedObjectForCache an object to which the cache will be attached
- * @returns {ParsedResource} parsed parts
- */
-export function parseResource(str: string, associatedObjectForCache?: Object | undefined): ParsedResource;
-export namespace parseResource {
-    function bindCache(associatedObjectForCache: any): (str: any) => any;
-}
-/**
- * @param {string} str the path with query and fragment
- * @param {Object=} associatedObjectForCache an object to which the cache will be attached
- * @returns {ParsedResource} parsed parts
- */
-export function parseResource(str: string, associatedObjectForCache?: Object | undefined): ParsedResource;
-export namespace parseResource { }
-export function getUndoPath(filename: string, outputPath: string, enforceRelative: boolean): string;
-export type MakeRelativePathsCache = {
-    relativePaths?: Map<string, Map<string, string>> | undefined;
-};
-export type ParsedResource = {
-    resource: string;
-    path: string;
-    query: string;
-    fragment: string;
-};
-export type ParsedResourceWithoutFragment = {
-    resource: string;
-    path: string;
-    query: string;
-};
-/**
- * @param {string} context context used to create relative path
- * @param {string} identifier identifier used to create relative path
- * @param {Object=} associatedObjectForCache an object to which the cache will be attached
- * @returns {string} the returned relative path
- */
-declare function makePathsRelative(context: string, identifier: string, associatedObjectForCache?: Object | undefined): string;
-declare namespace makePathsRelative { }
-/**
- * @param {string} context context used to create relative path
- * @param {string} identifier identifier used to create relative path
- * @param {Object=} associatedObjectForCache an object to which the cache will be attached
- * @returns {string} the returned relative path
- */
-declare function makePathsRelative(context: string, identifier: string, associatedObjectForCache?: Object | undefined): string;
-declare namespace makePathsRelative { }
-export { contextify, absolutify };

package/dist/helper/util/identifier.js

@@ -1,339 +0,0 @@
-"use strict";
-// @ts-nocheck
-/*
- * MIT License http://www.opensource.org/licenses/mit-license.php
- */
-const path = require("node:path");
-const WINDOWS_ABS_PATH_REGEXP = /^[a-zA-Z]:[\\/]/;
-const SEGMENTS_SPLIT_REGEXP = /([|!])/;
-const WINDOWS_PATH_SEPARATOR_REGEXP = /\\/g;
-/**
- * @typedef {Object} MakeRelativePathsCache
- * @property {Map<string, Map<string, string>>=} relativePaths
- */
-const relativePathToRequest = relativePath => {
-    if (relativePath === "")
-        return "./.";
-    if (relativePath === "..")
-        return "../.";
-    if (relativePath.startsWith("../"))
-        return relativePath;
-    return `./${relativePath}`;
-};
-/**
- * @param {string} context context for relative path
- * @param {string} maybeAbsolutePath path to make relative
- * @returns {string} relative path in request style
- */
-const absoluteToRequest = (context, maybeAbsolutePath) => {
-    if (maybeAbsolutePath[0] === "/") {
-        if (maybeAbsolutePath.length > 1 &&
-            maybeAbsolutePath[maybeAbsolutePath.length - 1] === "/") {
-            // this 'path' is actually a regexp generated by dynamic requires.
-            // Don't treat it as an absolute path.
-            return maybeAbsolutePath;
-        }
-        const querySplitPos = maybeAbsolutePath.indexOf("?");
-        let resource = querySplitPos === -1
-            ? maybeAbsolutePath
-            : maybeAbsolutePath.slice(0, querySplitPos);
-        resource = relativePathToRequest(path.posix.relative(context, resource));
-        return querySplitPos === -1
-            ? resource
-            : resource + maybeAbsolutePath.slice(querySplitPos);
-    }
-    if (WINDOWS_ABS_PATH_REGEXP.test(maybeAbsolutePath)) {
-        const querySplitPos = maybeAbsolutePath.indexOf("?");
-        let resource = querySplitPos === -1
-            ? maybeAbsolutePath
-            : maybeAbsolutePath.slice(0, querySplitPos);
-        resource = path.win32.relative(context, resource);
-        if (!WINDOWS_ABS_PATH_REGEXP.test(resource)) {
-            resource = relativePathToRequest(resource.replace(WINDOWS_PATH_SEPARATOR_REGEXP, "/"));
-        }
-        return querySplitPos === -1
-            ? resource
-            : resource + maybeAbsolutePath.slice(querySplitPos);
-    }
-    // not an absolute path
-    return maybeAbsolutePath;
-};
-/**
- * @param {string} context context for relative path
- * @param {string} relativePath path
- * @returns {string} absolute path
- */
-const requestToAbsolute = (context, relativePath) => {
-    if (relativePath.startsWith("./") || relativePath.startsWith("../"))
-        return path.join(context, relativePath);
-    return relativePath;
-};
-const makeCacheable = realFn => {
-    /** @type {WeakMap<object, Map<string, ParsedResource>>} */
-    const cache = new WeakMap();
-    const getCache = associatedObjectForCache => {
-        const entry = cache.get(associatedObjectForCache);
-        if (entry !== undefined)
-            return entry;
-        /** @type {Map<string, ParsedResource>} */
-        const map = new Map();
-        cache.set(associatedObjectForCache, map);
-        return map;
-    };
-    /**
-     * @param {string} str the path with query and fragment
-     * @param {Object=} associatedObjectForCache an object to which the cache will be attached
-     * @returns {ParsedResource} parsed parts
-     */
-    const fn = (str, associatedObjectForCache) => {
-        if (!associatedObjectForCache)
-            return realFn(str);
-        const cache = getCache(associatedObjectForCache);
-        const entry = cache.get(str);
-        if (entry !== undefined)
-            return entry;
-        const result = realFn(str);
-        cache.set(str, result);
-        return result;
-    };
-    fn.bindCache = associatedObjectForCache => {
-        const cache = getCache(associatedObjectForCache);
-        return str => {
-            const entry = cache.get(str);
-            if (entry !== undefined)
-                return entry;
-            const result = realFn(str);
-            cache.set(str, result);
-            return result;
-        };
-    };
-    return fn;
-};
-const makeCacheableWithContext = fn => {
-    /** @type {WeakMap<object, Map<string, Map<string, string>>>} */
-    const cache = new WeakMap();
-    /**
-     * @param {string} context context used to create relative path
-     * @param {string} identifier identifier used to create relative path
-     * @param {Object=} associatedObjectForCache an object to which the cache will be attached
-     * @returns {string} the returned relative path
-     */
-    const cachedFn = (context, identifier, associatedObjectForCache) => {
-        if (!associatedObjectForCache)
-            return fn(context, identifier);
-        let innerCache = cache.get(associatedObjectForCache);
-        if (innerCache === undefined) {
-            innerCache = new Map();
-            cache.set(associatedObjectForCache, innerCache);
-        }
-        let cachedResult;
-        let innerSubCache = innerCache.get(context);
-        if (innerSubCache === undefined) {
-            innerCache.set(context, (innerSubCache = new Map()));
-        }
-        else {
-            cachedResult = innerSubCache.get(identifier);
-        }
-        if (cachedResult !== undefined) {
-            return cachedResult;
-        }
-        const result = fn(context, identifier);
-        innerSubCache.set(identifier, result);
-        return result;
-    };
-    /**
-     * @param {Object=} associatedObjectForCache an object to which the cache will be attached
-     * @returns {function(string, string): string} cached function
-     */
-    cachedFn.bindCache = associatedObjectForCache => {
-        let innerCache;
-        if (associatedObjectForCache) {
-            innerCache = cache.get(associatedObjectForCache);
-            if (innerCache === undefined) {
-                innerCache = new Map();
-                cache.set(associatedObjectForCache, innerCache);
-            }
-        }
-        else {
-            innerCache = new Map();
-        }
-        /**
-         * @param {string} context context used to create relative path
-         * @param {string} identifier identifier used to create relative path
-         * @returns {string} the returned relative path
-         */
-        const boundFn = (context, identifier) => {
-            let cachedResult;
-            let innerSubCache = innerCache.get(context);
-            if (innerSubCache === undefined) {
-                innerCache.set(context, (innerSubCache = new Map()));
-            }
-            else {
-                cachedResult = innerSubCache.get(identifier);
-            }
-            if (cachedResult !== undefined) {
-                return cachedResult;
-            }
-            const result = fn(context, identifier);
-            innerSubCache.set(identifier, result);
-            return result;
-        };
-        return boundFn;
-    };
-    /**
-     * @param {string} context context used to create relative path
-     * @param {Object=} associatedObjectForCache an object to which the cache will be attached
-     * @returns {function(string): string} cached function
-     */
-    cachedFn.bindContextCache = (context, associatedObjectForCache) => {
-        let innerSubCache;
-        if (associatedObjectForCache) {
-            let innerCache = cache.get(associatedObjectForCache);
-            if (innerCache === undefined) {
-                innerCache = new Map();
-                cache.set(associatedObjectForCache, innerCache);
-            }
-            innerSubCache = innerCache.get(context);
-            if (innerSubCache === undefined) {
-                innerCache.set(context, (innerSubCache = new Map()));
-            }
-        }
-        else {
-            innerSubCache = new Map();
-        }
-        /**
-         * @param {string} identifier identifier used to create relative path
-         * @returns {string} the returned relative path
-         */
-        const boundFn = identifier => {
-            const cachedResult = innerSubCache.get(identifier);
-            if (cachedResult !== undefined) {
-                return cachedResult;
-            }
-            const result = fn(context, identifier);
-            innerSubCache.set(identifier, result);
-            return result;
-        };
-        return boundFn;
-    };
-    return cachedFn;
-};
-/**
- *
- * @param {string} context context for relative path
- * @param {string} identifier identifier for path
- * @returns {string} a converted relative path
- */
-const _makePathsRelative = (context, identifier) => {
-    return identifier
-        .split(SEGMENTS_SPLIT_REGEXP)
-        .map(str => absoluteToRequest(context, str))
-        .join("");
-};
-exports.makePathsRelative = makeCacheableWithContext(_makePathsRelative);
-/**
- *
- * @param {string} context context for relative path
- * @param {string} identifier identifier for path
- * @returns {string} a converted relative path
- */
-const _makePathsAbsolute = (context, identifier) => {
-    return identifier
-        .split(SEGMENTS_SPLIT_REGEXP)
-        .map(str => requestToAbsolute(context, str))
-        .join("");
-};
-exports.makePathsAbsolute = makeCacheableWithContext(_makePathsAbsolute);
-/**
- * @param {string} context absolute context path
- * @param {string} request any request string may containing absolute paths, query string, etc.
- * @returns {string} a new request string avoiding absolute paths when possible
- */
-const _contextify = (context, request) => {
-    return request
-        .split("!")
-        .map(r => absoluteToRequest(context, r))
-        .join("!");
-};
-const contextify = makeCacheableWithContext(_contextify);
-exports.contextify = contextify;
-/**
- * @param {string} context absolute context path
- * @param {string} request any request string
- * @returns {string} a new request string using absolute paths when possible
- */
-const _absolutify = (context, request) => {
-    return request
-        .split("!")
-        .map(r => requestToAbsolute(context, r))
-        .join("!");
-};
-const absolutify = makeCacheableWithContext(_absolutify);
-exports.absolutify = absolutify;
-const PATH_QUERY_FRAGMENT_REGEXP = /^((?:\u200b.|[^?#\u200b])*)(\?(?:\u200b.|[^#\u200b])*)?(#.*)?$/;
-const PATH_QUERY_REGEXP = /^((?:\u200b.|[^?\u200b])*)(\?.*)?$/;
-/** @typedef {{ resource: string, path: string, query: string, fragment: string }} ParsedResource */
-/** @typedef {{ resource: string, path: string, query: string }} ParsedResourceWithoutFragment */
-/**
- * @param {string} str the path with query and fragment
- * @returns {ParsedResource} parsed parts
- */
-const _parseResource = str => {
-    const match = PATH_QUERY_FRAGMENT_REGEXP.exec(str);
-    return {
-        resource: str,
-        path: match[1].replace(/\u200b(.)/g, "$1"),
-        query: match[2] ? match[2].replace(/\u200b(.)/g, "$1") : "",
-        fragment: match[3] || ""
-    };
-};
-exports.parseResource = makeCacheable(_parseResource);
-/**
- * Parse resource, skips fragment part
- * @param {string} str the path with query and fragment
- * @returns {ParsedResourceWithoutFragment} parsed parts
- */
-const _parseResourceWithoutFragment = str => {
-    const match = PATH_QUERY_REGEXP.exec(str);
-    return {
-        resource: str,
-        path: match[1].replace(/\u200b(.)/g, "$1"),
-        query: match[2] ? match[2].replace(/\u200b(.)/g, "$1") : ""
-    };
-};
-exports.parseResourceWithoutFragment = makeCacheable(_parseResourceWithoutFragment);
-/**
- * @param {string} filename the filename which should be undone
- * @param {string} outputPath the output path that is restored (only relevant when filename contains "..")
- * @param {boolean} enforceRelative true returns ./ for empty paths
- * @returns {string} repeated ../ to leave the directory of the provided filename to be back on output dir
- */
-exports.getUndoPath = (filename, outputPath, enforceRelative) => {
-    let depth = -1;
-    let append = "";
-    let path = outputPath.replace(/[\\/]$/, "");
-    for (const part of filename.split(/[/\\]+/)) {
-        if (part === "..") {
-            if (depth > -1) {
-                depth--;
-            }
-            else {
-                const i = path.lastIndexOf("/");
-                const j = path.lastIndexOf("\\");
-                const pos = i < 0 ? j : j < 0 ? i : Math.max(i, j);
-                if (pos < 0)
-                    return `${path}/`;
-                append = `${path.slice(pos + 1)}/${append}`;
-                path = path.slice(0, pos);
-            }
-        }
-        else if (part !== ".") {
-            depth++;
-        }
-    }
-    return depth > 0
-        ? `${"../".repeat(depth)}${append}`
-        : enforceRelative
-            ? `./${append}`
-            : append;
-};

package/dist/helper/util/replaceMitteDiagnostic.d.ts

@@ -1,2 +0,0 @@
-export function replace(s: any): any;
-export function replaceStack(s: any): any;

package/dist/helper/util/replaceMitteDiagnostic.js

@@ -1,17 +0,0 @@
-"use strict";
-// @ts-nocheck
-// Remove the "|" padding from miette,
-// used to ensure no line breaks with padding being returned,
-// miette generates diagnostics lines with respect to terminal size
-// and this might varies among different `process.cwd()` being used,
-// which breaks local and CI checks.
-const replace = s => s.replace(/\r?\n[ ]+│ /g, "");
-// HOW THIS WORKS:
-// 1. Remove potential line break and "|"
-// 2. Save the JS stack for each line
-// 3. If the current line was splitted because of terminal size, merge them together
-const replaceStack = s => s.replace(/(?:\s|│)*(at.*)(\s|│)*/g, "\n$1");
-module.exports = {
-    replace,
-    replaceStack
-};

package/dist/plugin/rspack-diff-config-plugin.d.ts

@@ -1,7 +0,0 @@
-import type { Compiler, RspackOptionsNormalized, RspackPluginInstance } from "@rspack/core";
-export declare class RspackDiffConfigPlugin implements RspackPluginInstance {
-    private modifier?;
-    name: string;
-    constructor(modifier?: ((options: RspackOptionsNormalized) => RspackOptionsNormalized) | undefined);
-    apply(compiler: Compiler): void;
-}

package/dist/plugin/rspack-diff-config-plugin.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RspackDiffConfigPlugin = void 0;
-const PLUGIN_NAME = "RspackDiffConfigPlugin";
-class RspackDiffConfigPlugin {
-    constructor(modifier) {
-        this.modifier = modifier;
-        this.name = PLUGIN_NAME;
-        process.env.RSPACK_DIFF = "true"; // enable rspack diff
-    }
-    apply(compiler) {
-        const { options } = compiler;
-        options.mode = "development";
-        options.devtool = false;
-        options.optimization ??= {};
-        options.optimization.minimize = false;
-        options.optimization.chunkIds = "named";
-        options.optimization.moduleIds = "named";
-        options.optimization.mangleExports ??= false;
-        options.optimization.concatenateModules ??= false;
-        options.output ??= {};
-        options.output.pathinfo ??= false;
-        options.output.environment ??= {};
-        options.output.environment.arrowFunction ??= false;
-        options.output.environment.bigIntLiteral ??= false;
-        options.output.environment.const ??= false;
-        options.output.environment.destructuring ??= false;
-        options.output.environment.dynamicImport ??= false;
-        options.output.environment.dynamicImportInWorker ??= false;
-        options.output.environment.forOf ??= false;
-        options.output.environment.globalThis ??= false;
-        options.output.environment.module ??= false;
-        options.output.environment.optionalChaining ??= false;
-        options.output.environment.templateLiteral ??= false;
-        options.experiments ??= {};
-        options.experiments.rspackFuture ??= {};
-        if (typeof this.modifier === "function") {
-            this.modifier(compiler.options);
-        }
-    }
-}
-exports.RspackDiffConfigPlugin = RspackDiffConfigPlugin;

package/dist/plugin/webpack-diff-config-plugin.d.ts

@@ -1,7 +0,0 @@
-import type { Compiler, WebpackOptionsNormalized } from "webpack";
-export declare class WebpackDiffConfigPlugin {
-    private modifier?;
-    name: string;
-    constructor(modifier?: ((options: WebpackOptionsNormalized) => WebpackOptionsNormalized) | undefined);
-    apply(compiler: Compiler): void;
-}