knip 5.70.1 → 5.71.0

package/dist/util/plugin.js

@@ -16,9 +16,8 @@ export const hasDependency = (dependencies, values) => values.some(value => {
     return false;
 });
 export const normalizePluginConfig = (pluginConfig) => {
-    if (typeof pluginConfig === 'boolean') {
+    if (typeof pluginConfig === 'boolean')
         return pluginConfig;
-    }
     const isObject = typeof pluginConfig !== 'string' && !Array.isArray(pluginConfig);
     const config = isObject
         ? 'config' in pluginConfig
@@ -28,7 +27,9 @@ export const normalizePluginConfig = (pluginConfig) => {
             ? arrayify(pluginConfig)
             : null;
     const entry = isObject && 'entry' in pluginConfig ? arrayify(pluginConfig.entry) : null;
-    const project = isObject && 'project' in pluginConfig ? arrayify(pluginConfig.project) : entry;
+    const project = isObject && 'project' in pluginConfig
+        ? arrayify(pluginConfig.project)
+        : (entry ?? []).filter(pattern => !pattern.startsWith('!'));
     return { config, entry, project };
 };
 export const loadConfigForPlugin = async (configFilePath, plugin, options, pluginName) => {

package/dist/util/trace.d.ts

@@ -1,20 +1,10 @@
-import type { ModuleGraph } from '../types/module-graph.js';
 import type { MainOptions } from './create-options.js';
-type CreateNodeOpts = {
-    identifier?: string;
-    hasRef?: boolean;
-    isEntry?: boolean;
-};
-type Create = (filePath: string, options?: CreateNodeOpts) => TraceNode;
-export type TraceNode = {
+type ExplorerTraceNode = {
     filePath: string;
     identifier?: string;
     hasRef: boolean;
     isEntry: boolean;
-    children: Set<TraceNode>;
+    children: ExplorerTraceNode[];
 };
-export declare const printTrace: (node: TraceNode, filePath: string, options: MainOptions, identifier?: string) => void;
-export declare const createNode: Create;
-export declare const addNodes: (node: TraceNode, id: string, importedSymbols: ModuleGraph, filePaths?: Set<string>) => void;
-export declare const createAndPrintTrace: (filePath: string, options: MainOptions, opts?: CreateNodeOpts) => void;
+export declare const printTraceNode: (node: ExplorerTraceNode, options: MainOptions) => void;
 export {};

package/dist/util/trace.js

@@ -1,5 +1,5 @@
 import picocolors from 'picocolors';
-import { toAbsolute, toRelative } from './path.js';
+import { toRelative } from './path.js';
 const IS_ENTRY = ' ◯';
 const HAS_REF = ' ✓';
 const HAS_NO_REF = ' x';
@@ -9,62 +9,31 @@ const getPadding = (level, levels) => {
         padding += levels.has(i) ? `${picocolors.dim('│')}  ` : '   ';
     return padding;
 };
-const renderTrace = (node, options, level = 0, levels = new Set()) => {
+const renderExplorerTrace = (node, options, level = 0, levels = new Set()) => {
     let index = 0;
-    const size = node.children.size;
+    const size = node.children.length;
     const padding = getPadding(level, levels);
     for (const child of node.children) {
         const isLast = ++index === size;
         const hasRef = child.hasRef === true;
         const rel = toRelative(child.filePath, options.cwd);
         const file = hasRef ? rel : picocolors.dim(rel);
-        const suffix = (hasRef ? HAS_REF : '') + (child.isEntry ? IS_ENTRY : '');
+        const suffix = hasRef ? HAS_REF : '';
         const text = `${padding}${picocolors.dim(isLast ? '└─' : '├─')} ${file}${suffix}`;
         console.log(text);
-        if (child.children.size > 0) {
+        if (child.children.length > 0) {
             if (!isLast)
                 levels.add(level);
             if (isLast)
                 levels.delete(level);
-            renderTrace(child, options, level + 1, levels);
+            renderExplorerTrace(child, options, level + 1, levels);
         }
     }
 };
-export const printTrace = (node, filePath, options, identifier) => {
-    if (!options.isTrace)
-        return;
-    if (options.traceExport && identifier !== options.traceExport)
-        return;
-    if (options.traceFile && filePath !== toAbsolute(options.traceFile, options.cwd))
-        return;
-    const suffix = (node.isEntry ? IS_ENTRY : '') + (node.children.size === 0 ? HAS_NO_REF : '');
-    const header = `${toRelative(filePath, options.cwd)}${identifier ? `:${identifier}` : ''}${suffix}`;
+export const printTraceNode = (node, options) => {
+    const suffix = (node.isEntry ? IS_ENTRY : '') + (node.children.length === 0 ? HAS_NO_REF : '');
+    const header = `${toRelative(node.filePath, options.cwd)}${node.identifier ? `:${node.identifier}` : ''}${suffix}`;
     console.log(header);
-    renderTrace(node, options);
+    renderExplorerTrace(node, options);
     console.log();
 };
-export const createNode = (filePath, { hasRef = false, isEntry = false, identifier } = {}) => ({
-    filePath,
-    identifier,
-    hasRef,
-    isEntry,
-    children: new Set(),
-});
-const addNode = (parent, filePath, { hasRef = false, isEntry = false }) => {
-    const node = createNode(filePath, { hasRef, isEntry });
-    parent.children.add(node);
-    return node;
-};
-export const addNodes = (node, id, importedSymbols, filePaths) => {
-    if (!filePaths)
-        return;
-    for (const filePath of filePaths) {
-        addNode(node, filePath, { hasRef: Boolean(importedSymbols.get(filePath)?.traceRefs?.has(id)) });
-    }
-};
-export const createAndPrintTrace = (filePath, options, opts = {}) => {
-    if (!options.isTrace)
-        return;
-    const traceNode = createNode(filePath, opts);
-    printTrace(traceNode, filePath, options, opts.identifier);
-};

package/dist/util/watch.d.ts

@@ -6,10 +6,16 @@ import type { ProjectPrincipal } from '../ProjectPrincipal.js';
 import type { Issues } from '../types/issues.js';
 import type { ModuleGraph } from '../types/module-graph.js';
 import type { MainOptions } from './create-options.js';
-export type OnUpdate = (options: {
+export type OnFileChange = (options: {
     issues: Issues;
     duration?: number;
+    mem?: number;
 }) => void;
+type WatchChange = {
+    type: 'added' | 'deleted' | 'modified';
+    filePath: string;
+};
+export type WatchHandler = Awaited<ReturnType<typeof getWatchHandler>>;
 type Watch = {
     analyzedFiles: Set<string>;
     analyzeSourceFile: (filePath: string, principal: ProjectPrincipal) => void;
@@ -19,8 +25,18 @@ type Watch = {
     factory: PrincipalFactory;
     graph: ModuleGraph;
     isIgnored: (path: string) => boolean;
-    onUpdate: OnUpdate;
+    onFileChange?: OnFileChange;
     unreferencedFiles: Set<string>;
+    entryPaths: Set<string>;
 };
-export declare const getWatchHandler: (options: MainOptions, { analyzedFiles, analyzeSourceFile, chief, collector, analyze, factory, graph, isIgnored, onUpdate, unreferencedFiles, }: Watch) => Promise<WatchListener<string | Buffer<ArrayBufferLike>>>;
+export declare const getWatchHandler: (options: MainOptions, { analyzedFiles, analyzeSourceFile, chief, collector, analyze, factory, graph, isIgnored, onFileChange, unreferencedFiles, entryPaths, }: Watch) => Promise<{
+    listener: WatchListener<string | Buffer<ArrayBufferLike>>;
+    handleFileChanges: (changes: WatchChange[]) => Promise<{
+        duration: number;
+        mem: number;
+    }>;
+    getEntryPaths: () => Set<string>;
+    getGraph: () => ModuleGraph;
+    getIssues: () => Issues;
+}>;
 export {};

package/dist/util/watch.js

@@ -2,18 +2,23 @@ import { debugLog } from './debug.js';
 import { isFile } from './fs.js';
 import { updateImportMap } from './module-graph.js';
 import { join, toAbsolute, toRelative } from './path.js';
-export const getWatchHandler = async (options, { analyzedFiles, analyzeSourceFile, chief, collector, analyze, factory, graph, isIgnored, onUpdate, unreferencedFiles, }) => {
+const createUpdate = (options) => {
+    const duration = performance.now() - options.startTime;
+    const mem = process.memoryUsage().heapUsed;
+    return { duration, mem };
+};
+export const getWatchHandler = async (options, { analyzedFiles, analyzeSourceFile, chief, collector, analyze, factory, graph, isIgnored, onFileChange, unreferencedFiles, entryPaths, }) => {
     const getIssues = () => collector.getIssues().issues;
-    const processBatch = async (changes) => {
+    const handleFileChanges = async (changes) => {
         const startTime = performance.now();
         const added = new Set();
         const deleted = new Set();
         const modified = new Set();
-        for (const [type, _path] of changes) {
-            const filePath = toAbsolute(_path, options.cwd);
-            const relativePath = toRelative(_path, options.cwd);
+        for (const change of changes) {
+            const filePath = toAbsolute(change.filePath, options.cwd);
+            const relativePath = toRelative(change.filePath, options.cwd);
             if (isIgnored(filePath)) {
-                debugLog('*', `ignoring ${type} ${relativePath}`);
+                debugLog('*', `ignoring ${change.type} ${relativePath}`);
                 continue;
             }
             const workspace = chief.findWorkspaceByFilePath(filePath);
@@ -22,7 +27,7 @@ export const getWatchHandler = async (options, { analyzedFiles, analyzeSourceFil
             const principal = factory.getPrincipalByPackageName(workspace.pkgName);
             if (!principal)
                 continue;
-            switch (type) {
+            switch (change.type) {
                 case 'added':
                     added.add(filePath);
                     principal.addProjectPath(filePath);
@@ -35,7 +40,7 @@ export const getWatchHandler = async (options, { analyzedFiles, analyzeSourceFil
                     principal.removeProjectPath(filePath);
                     debugLog(workspace.name, `Watcher: - ${relativePath}`);
                     break;
-                case 'modified':
+                default:
                     modified.add(filePath);
                     debugLog(workspace.name, `Watcher: ± ${relativePath}`);
                     break;
@@ -43,7 +48,7 @@ export const getWatchHandler = async (options, { analyzedFiles, analyzeSourceFil
             principal.invalidateFile(filePath);
         }
         if (added.size === 0 && deleted.size === 0 && modified.size === 0)
-            return;
+            return createUpdate({ startTime });
         unreferencedFiles.clear();
         const cachedUnusedFiles = collector.purge();
         for (const filePath of added)
@@ -110,15 +115,21 @@ export const getWatchHandler = async (options, { analyzedFiles, analyzeSourceFil
         collector.addFileCounts({ processed: analyzedFiles.size, unused: unusedFiles.length });
         for (const issue of collector.getRetainedIssues())
             collector.addIssue(issue);
-        onUpdate({ issues: getIssues(), duration: performance.now() - startTime });
+        const update = createUpdate({ startTime });
+        if (onFileChange)
+            onFileChange(Object.assign({ issues: getIssues() }, update));
+        return update;
     };
-    const listener = (eventType, filename) => {
-        debugLog('*', `(raw) ${eventType} ${filename}`);
-        if (typeof filename === 'string') {
-            const event = eventType === 'rename' ? (isFile(join(options.cwd, filename)) ? 'added' : 'deleted') : 'modified';
-            processBatch([[event, filename]]);
+    const listener = (eventType, filePath) => {
+        debugLog('*', `(raw) ${eventType} ${filePath}`);
+        if (typeof filePath === 'string') {
+            const type = eventType === 'rename' ? (isFile(join(options.cwd, filePath)) ? 'added' : 'deleted') : 'modified';
+            handleFileChanges([{ type, filePath }]);
         }
     };
-    onUpdate({ issues: getIssues() });
-    return listener;
+    if (onFileChange)
+        onFileChange({ issues: getIssues() });
+    const getEntryPaths = () => entryPaths;
+    const getGraph = () => graph;
+    return { listener, handleFileChanges, getEntryPaths, getGraph, getIssues };
 };

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "5.70.1";
+export declare const version = "5.71.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '5.70.1';
+export const version = '5.71.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "5.70.1",
+  "version": "5.71.0",
   "description": "Find and fix unused dependencies, exports and files in your TypeScript and JavaScript projects",
   "homepage": "https://knip.dev",
   "repository": {

package/vendor/bash-parser/index.d.ts

@@ -43,6 +43,11 @@ type Function_ = {
   body: CompoundList;
 };
 
+type Subshell = {
+  type: 'Subshell';
+  list: CompoundList;
+};
+
 export type ExpansionNode = {
   expansion: Expansion[];
 };
@@ -62,7 +67,7 @@ export type Assignment = {
   text: string;
 };
 
-export type Node = CompoundList | Command | LogicalExpression | If | For | Function_ | Pipeline;
+export type Node = CompoundList | Command | LogicalExpression | If | For | Function_ | Pipeline | Subshell;
 
 export type AST = {
   type: 'Script';

package/dist/util/has-strictly-ns-references.d.ts

@@ -1,4 +0,0 @@
-import type { ImportMaps, ModuleGraph } from '../types/module-graph.js';
-export declare const hasStrictlyEnumReferences: (importsForExport: ImportMaps | undefined, id: string) => boolean;
-export declare const hasStrictlyNsReferences: (graph: ModuleGraph, importsForExport: ImportMaps | undefined, id: string) => [boolean, string?];
-export declare const getType: (hasOnlyNsReference: boolean, isType: boolean) => "exports" | "nsExports" | "types" | "nsTypes";

package/dist/util/has-strictly-ns-references.js

@@ -1,103 +0,0 @@
-import { IMPORT_STAR } from '../constants.js';
-export const hasStrictlyEnumReferences = (importsForExport, id) => {
-    if (!importsForExport || !importsForExport.refs.has(id))
-        return false;
-    for (const ref of importsForExport.refs)
-        if (ref.startsWith(`${id}.`))
-            return false;
-    return true;
-};
-export const hasStrictlyNsReferences = (graph, importsForExport, id) => {
-    if (!importsForExport)
-        return [false];
-    let namespace;
-    for (const ns of importsForExport.importedNs.keys()) {
-        const hasNs = importsForExport.refs.has(ns);
-        if (!hasNs)
-            return [false, ns];
-        for (const id of importsForExport.refs)
-            if (id.startsWith(`${ns}.`))
-                return [false, ns];
-        const byFilePaths = importsForExport.reExportedNs.get(ns);
-        if (byFilePaths) {
-            for (const filePath of byFilePaths) {
-                const file = graph.get(filePath);
-                if (file?.imported) {
-                    const hasStrictlyNsRefs = hasStrictlyNsReferences(graph, file.imported, id);
-                    if (hasStrictlyNsRefs[0] === false)
-                        return hasStrictlyNsRefs;
-                }
-            }
-        }
-        const reExportedAs = importsForExport.reExportedAs.get(ns);
-        if (reExportedAs) {
-            for (const byFilePaths of reExportedAs.values()) {
-                for (const filePath of byFilePaths) {
-                    const file = graph.get(filePath);
-                    if (file?.imported) {
-                        const hasStrictlyNsRefs = hasStrictlyNsReferences(graph, file.imported, id);
-                        if (hasStrictlyNsRefs[0] === false)
-                            return hasStrictlyNsRefs;
-                    }
-                }
-            }
-        }
-        namespace = ns;
-    }
-    const byFilePaths = importsForExport.reExported.get(id);
-    if (byFilePaths) {
-        for (const filePath of byFilePaths) {
-            const file = graph.get(filePath);
-            if (file?.imported) {
-                const hasStrictlyNsRefs = hasStrictlyNsReferences(graph, file.imported, id);
-                if (hasStrictlyNsRefs[0] === false)
-                    return hasStrictlyNsRefs;
-                namespace = hasStrictlyNsRefs[1];
-            }
-        }
-    }
-    {
-        const byFilePaths = importsForExport.reExported.get(IMPORT_STAR);
-        if (byFilePaths) {
-            for (const filePath of byFilePaths) {
-                const file = graph.get(filePath);
-                if (file?.imported) {
-                    const hasStrictlyNsRefs = hasStrictlyNsReferences(graph, file.imported, id);
-                    if (hasStrictlyNsRefs[0] === false)
-                        return hasStrictlyNsRefs;
-                    namespace = hasStrictlyNsRefs[1];
-                }
-            }
-        }
-    }
-    const [identifier, ...rest] = id.split('.');
-    const reExportedAs = importsForExport.reExportedAs.get(identifier);
-    if (reExportedAs) {
-        for (const [alias, filePaths] of reExportedAs.entries()) {
-            for (const filePath of filePaths) {
-                const file = graph.get(filePath);
-                if (file?.imported) {
-                    const hasStrictlyNsRefs = hasStrictlyNsReferences(graph, file.imported, [alias, ...rest].join('.'));
-                    if (hasStrictlyNsRefs[0] === false)
-                        return hasStrictlyNsRefs;
-                    namespace = hasStrictlyNsRefs[1];
-                }
-            }
-        }
-    }
-    for (const [ns, filePaths] of importsForExport.reExportedNs.entries()) {
-        for (const filePath of filePaths) {
-            const file = graph.get(filePath);
-            if (file?.imported) {
-                const hasStrictlyNsRefs = hasStrictlyNsReferences(graph, file.imported, `${ns}.${id}`);
-                if (hasStrictlyNsRefs[0] === false)
-                    return hasStrictlyNsRefs;
-                namespace = hasStrictlyNsRefs[1];
-            }
-        }
-    }
-    if (namespace)
-        return [true, namespace];
-    return [false];
-};
-export const getType = (hasOnlyNsReference, isType) => hasOnlyNsReference ? (isType ? 'nsTypes' : 'nsExports') : isType ? 'types' : 'exports';

package/dist/util/is-identifier-referenced.d.ts

@@ -1,9 +0,0 @@
-import type { ModuleGraph } from '../types/module-graph.js';
-import { type TraceNode } from './trace.js';
-type Result = {
-    isReferenced: boolean;
-    reExportingEntryFile: undefined | string;
-    traceNode: TraceNode;
-};
-export declare const getIsIdentifierReferencedHandler: (graph: ModuleGraph, entryPaths: Set<string>, isTrace: boolean) => (filePath: string, id: string, isIncludeEntryExports?: boolean, traceNode?: TraceNode, seen?: Set<string>) => Result;
-export {};

package/dist/util/is-identifier-referenced.js

@@ -1,145 +0,0 @@
-import { IMPORT_STAR, OPAQUE } from '../constants.js';
-import { addNodes, createNode } from './trace.js';
-export const getIsIdentifierReferencedHandler = (graph, entryPaths, isTrace) => {
-    const isIdentifierReferenced = (filePath, id, isIncludeEntryExports = false, traceNode = createNode(filePath), seen = new Set()) => {
-        let isReferenced = false;
-        let reExportingEntryFile = entryPaths.has(filePath) ? filePath : undefined;
-        if (reExportingEntryFile)
-            traceNode.isEntry = true;
-        if (!isIncludeEntryExports && reExportingEntryFile)
-            return { isReferenced, reExportingEntryFile, traceNode };
-        seen.add(filePath);
-        const restIds = id.split('.');
-        const identifier = restIds.shift();
-        const file = graph.get(filePath)?.imported;
-        if (!identifier || !file)
-            return { isReferenced, reExportingEntryFile, traceNode };
-        if (file.imported.get(OPAQUE) ||
-            ((identifier === id || (identifier !== id && file.refs.has(id))) &&
-                (file.imported.has(identifier) || file.importedAs.has(identifier)))) {
-            isReferenced = true;
-            if (!isTrace)
-                return { isReferenced, reExportingEntryFile, traceNode };
-            if (file.importedAs.has(identifier)) {
-                for (const aliases of file.importedAs.values()) {
-                    for (const alias of aliases.keys())
-                        addNodes(traceNode, alias, graph, aliases.get(alias));
-                }
-            }
-            else
-                addNodes(traceNode, id, graph, file.imported.get(identifier));
-        }
-        for (const [exportId, aliases] of file.importedAs.entries()) {
-            if (identifier === exportId) {
-                for (const alias of aliases.keys()) {
-                    const aliasedRef = [alias, ...restIds].join('.');
-                    if (file.refs.has(aliasedRef)) {
-                        isReferenced = true;
-                        if (!isTrace)
-                            return { isReferenced, reExportingEntryFile, traceNode };
-                        addNodes(traceNode, aliasedRef, graph, aliases.get(alias));
-                    }
-                }
-            }
-        }
-        for (const [namespace, byFilePaths] of file.importedNs) {
-            if (file.refs.has(`${namespace}.${id}`)) {
-                isReferenced = true;
-                if (!isTrace)
-                    return { isReferenced, reExportingEntryFile, traceNode };
-                addNodes(traceNode, `${namespace}.${id}`, graph, byFilePaths);
-            }
-            const reExportedAs = file.reExportedAs.get(namespace);
-            if (reExportedAs) {
-                for (const [alias, byFilePaths] of reExportedAs) {
-                    for (const byFilePath of byFilePaths) {
-                        if (!seen.has(byFilePath)) {
-                            const child = createNode(byFilePath);
-                            traceNode.children.add(child);
-                            const result = isIdentifierReferenced(byFilePath, `${alias}.${id}`, isIncludeEntryExports, child, seen);
-                            if (result.reExportingEntryFile)
-                                reExportingEntryFile = result.reExportingEntryFile;
-                            if (result.isReferenced) {
-                                isReferenced = true;
-                                if (!isTrace)
-                                    return { isReferenced, reExportingEntryFile, traceNode };
-                            }
-                        }
-                    }
-                }
-            }
-            const reExportedNs = file.reExportedNs.get(namespace);
-            if (reExportedNs) {
-                for (const byFilePath of reExportedNs) {
-                    if (!seen.has(byFilePath)) {
-                        const child = createNode(byFilePath);
-                        traceNode.children.add(child);
-                        const result = isIdentifierReferenced(byFilePath, `${namespace}.${id}`, isIncludeEntryExports, child, seen);
-                        if (result.reExportingEntryFile)
-                            reExportingEntryFile = result.reExportingEntryFile;
-                        if (result.isReferenced) {
-                            isReferenced = true;
-                            if (!isTrace)
-                                return { isReferenced, reExportingEntryFile, traceNode };
-                        }
-                    }
-                }
-            }
-        }
-        const reExportedAs = file.reExportedAs.get(identifier);
-        if (reExportedAs) {
-            for (const [alias, byFilePaths] of reExportedAs) {
-                for (const byFilePath of byFilePaths) {
-                    if (!seen.has(byFilePath)) {
-                        const child = createNode(byFilePath);
-                        traceNode.children.add(child);
-                        const ref = [alias, ...restIds].join('.');
-                        const result = isIdentifierReferenced(byFilePath, ref, isIncludeEntryExports, child, seen);
-                        if (result.reExportingEntryFile)
-                            reExportingEntryFile = result.reExportingEntryFile;
-                        if (result.isReferenced) {
-                            isReferenced = true;
-                            if (!isTrace)
-                                return { isReferenced, reExportingEntryFile, traceNode };
-                        }
-                    }
-                }
-            }
-        }
-        const reExported = file.reExported.get(identifier) ?? file.reExported.get(IMPORT_STAR);
-        if (reExported) {
-            for (const byFilePath of reExported) {
-                if (!seen.has(byFilePath)) {
-                    const child = createNode(byFilePath);
-                    traceNode.children.add(child);
-                    const result = isIdentifierReferenced(byFilePath, id, isIncludeEntryExports, child, seen);
-                    if (result.reExportingEntryFile)
-                        reExportingEntryFile = result.reExportingEntryFile;
-                    if (result.isReferenced) {
-                        isReferenced = true;
-                        if (!isTrace)
-                            return { isReferenced, reExportingEntryFile, traceNode };
-                    }
-                }
-            }
-        }
-        for (const [namespace, byFilePaths] of file.reExportedNs.entries()) {
-            for (const byFilePath of byFilePaths) {
-                if (!seen.has(byFilePath)) {
-                    const child = createNode(byFilePath);
-                    traceNode.children.add(child);
-                    const result = isIdentifierReferenced(byFilePath, `${namespace}.${id}`, isIncludeEntryExports, child, seen);
-                    if (result.reExportingEntryFile)
-                        reExportingEntryFile = result.reExportingEntryFile;
-                    if (result.isReferenced) {
-                        isReferenced = true;
-                        if (!isTrace)
-                            return { isReferenced, reExportingEntryFile, traceNode };
-                    }
-                }
-            }
-        }
-        return { isReferenced, reExportingEntryFile, traceNode };
-    };
-    return isIdentifierReferenced;
-};