@openclaw/fs-safe 0.10.0 → 0.12.0

package/dist/root-path-symlink.js

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { FsSafeError } from "./errors.js";
 import { isNotFoundPathError, isSymlinkOpenError } from "./path.js";
+import { realpathSync } from "./realpath.js";
 import { resolvePathViaExistingAncestor, resolvePathViaExistingAncestorSync, } from "./root-path-existing.js";
 function normalizeSymlinkResolutionError(error, options) {
     if (isSymlinkOpenError(error) ||
@@ -15,7 +16,7 @@ function normalizeSymlinkResolutionError(error, options) {
 }
 export async function resolveSymlinkHopPath(symlinkPath, options = {}) {
     try {
-        return path.resolve(fs.realpathSync.native(symlinkPath));
+        return path.resolve(realpathSync.native(symlinkPath));
     }
     catch (error) {
         normalizeSymlinkResolutionError(error, options);
@@ -25,7 +26,7 @@ export async function resolveSymlinkHopPath(symlinkPath, options = {}) {
 }
 export function resolveSymlinkHopPathSync(symlinkPath, options = {}) {
     try {
-        return path.resolve(fs.realpathSync(symlinkPath));
+        return path.resolve(realpathSync(symlinkPath));
     }
     catch (error) {
         normalizeSymlinkResolutionError(error, options);

package/dist/root-path.d.ts

@@ -1,3 +1,4 @@
+import { type RootBoundaryIdentity } from "./root-boundary.js";
 export { resolvePathViaExistingAncestorSync } from "./root-path-existing.js";
 type RootPathIntent = "read" | "write" | "create" | "delete" | "stat";
 export type RootPathAliasPolicy = {
@@ -25,6 +26,7 @@ type ResolveRootPathParams = {
     rejectUnresolvedSymlinks?: boolean;
     skipLexicalRootCheck?: boolean;
     rootCanonicalPath?: string;
+    rootIdentity?: RootBoundaryIdentity;
 };
 type ResolvedRootPathKind = "missing" | "file" | "directory" | "symlink" | "other";
 export type ResolvedRootPath = {

package/dist/root-path.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"root-path.d.ts","sourceRoot":"","sources":["../src/root-path.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAE,kCAAkC,EAAE,MAAM,yBAAyB,CAAC;AAE7E,KAAK,cAAc,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAAC;AAEtE,MAAM,MAAM,mBAAmB,GAAG;IAChC,0BAA0B,CAAC,EAAE,OAAO,CAAC;IACrC,2BAA2B,CAAC,EAAE,OAAO,CAAC;CACvC,CAAC;AAEF,eAAO,MAAM,wBAAwB;aACnC,MAAM;;;;aAIN,YAAY;;;;CAIJ,CAAC;AAEX,KAAK,qBAAqB,GAAG;IAC3B,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,cAAc,CAAC;IACxB,MAAM,CAAC,EAAE,mBAAmB,CAAC;IAC7B,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,KAAK,oBAAoB,GAAG,SAAS,GAAG,MAAM,GAAG,WAAW,GAAG,SAAS,GAAG,OAAO,CAAC;AAEnF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,EAAE,oBAAoB,CAAC;CAC5B,CAAC;AAEF,wBAAsB,eAAe,CACnC,MAAM,EAAE,qBAAqB,GAC5B,OAAO,CAAC,gBAAgB,CAAC,CAM3B;AAeD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,qBAAqB,GAAG,gBAAgB,CAMnF"}
+{"version":3,"file":"root-path.d.ts","sourceRoot":"","sources":["../src/root-path.ts"],"names":[],"mappings":"AAeA,OAAO,EAGL,KAAK,oBAAoB,EAC1B,MAAM,oBAAoB,CAAC;AAI5B,OAAO,EAAE,kCAAkC,EAAE,MAAM,yBAAyB,CAAC;AAE7E,KAAK,cAAc,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAAC;AAEtE,MAAM,MAAM,mBAAmB,GAAG;IAChC,0BAA0B,CAAC,EAAE,OAAO,CAAC;IACrC,2BAA2B,CAAC,EAAE,OAAO,CAAC;CACvC,CAAC;AAEF,eAAO,MAAM,wBAAwB;aACnC,MAAM;;;;aAIN,YAAY;;;;CAIJ,CAAC;AAEX,KAAK,qBAAqB,GAAG;IAC3B,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,cAAc,CAAC;IACxB,MAAM,CAAC,EAAE,mBAAmB,CAAC;IAC7B,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,YAAY,CAAC,EAAE,oBAAoB,CAAC;CACrC,CAAC;AAEF,KAAK,oBAAoB,GAAG,SAAS,GAAG,MAAM,GAAG,WAAW,GAAG,SAAS,GAAG,OAAO,CAAC;AAEnF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,EAAE,oBAAoB,CAAC;CAC5B,CAAC;AAEF,wBAAsB,eAAe,CACnC,MAAM,EAAE,qBAAqB,GAC5B,OAAO,CAAC,gBAAgB,CAAC,CAM3B;AAcD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,qBAAqB,GAAG,gBAAgB,CAMnF"}

package/dist/root-path.js

@@ -2,8 +2,9 @@ import fs from "node:fs";
 import path from "node:path";
 import { formatErrorDetail, shortPath } from "./error-detail.js";
 import { FsSafeError } from "./errors.js";
-import { assertNoNulPathInput, isNotFoundPathError, isPathInside, isPathRelativeEscape, } from "./path.js";
+import { assertNoNulPathInput, isNotFoundPathError, isPathRelativeEscape, } from "./path.js";
 import { absolutePathWithRawSegments, rawPathRelativeToCanonicalRoot, resolvePathViaExistingAncestor, resolvePathViaExistingAncestorSync, } from "./root-path-existing.js";
+import { admitPathInsideRoot, } from "./root-boundary.js";
 import { resolveSymlinkHopPath, resolveSymlinkHopPathSync } from "./root-path-symlink.js";
 import { assertNoDriveRelativePathSegments } from "./safe-path-segment.js";
 export { resolvePathViaExistingAncestorSync } from "./root-path-existing.js";
@@ -29,11 +30,10 @@ async function resolveRootPathInternal(params) {
     assertValidRootPathInputs(params);
     params = { ...params, absolutePath: absolutePathWithRawSegments(params.absolutePath) };
     const rootPath = path.resolve(params.rootPath);
-    const absolutePath = path.resolve(params.absolutePath);
     const rootCanonicalPath = params.rootCanonicalPath
         ? path.resolve(params.rootCanonicalPath)
         : await resolvePathViaExistingAncestor(rootPath);
-    return resolveRootPathLexicalAsync(prepareRootTraversal(params, rootPath, rootCanonicalPath, absolutePath));
+    return resolveRootPathLexicalAsync(prepareRootTraversal(params, rootPath, rootCanonicalPath));
 }
 export function resolveRootPathSync(params) {
     try {
@@ -47,25 +47,38 @@ function resolveRootPathSyncInternal(params) {
     assertValidRootPathInputs(params);
     params = { ...params, absolutePath: absolutePathWithRawSegments(params.absolutePath) };
     const rootPath = path.resolve(params.rootPath);
-    const absolutePath = path.resolve(params.absolutePath);
     const rootCanonicalPath = params.rootCanonicalPath
         ? path.resolve(params.rootCanonicalPath)
         : resolvePathViaExistingAncestorSync(rootPath);
-    return resolveRootPathLexicalSync(prepareRootTraversal(params, rootPath, rootCanonicalPath, absolutePath));
+    return resolveRootPathLexicalSync(prepareRootTraversal(params, rootPath, rootCanonicalPath));
 }
-function prepareRootTraversal(params, rootPath, rootCanonicalPath, absolutePath) {
+function prepareRootTraversal(params, rootPath, rootCanonicalPath) {
+    const callerAbsolutePath = path.resolve(params.absolutePath);
     let raw = params.absolutePath;
-    if (rawPathRelativeToRoot(rootPath, raw) === undefined) {
-        const relative = rawPathRelativeToRoot(rootCanonicalPath, raw)
+    let trustedAbsolutePath = false;
+    const direct = admitRawPathInsideRoot(rootPath, raw, params.rootIdentity);
+    if (direct) {
+        raw = direct.path;
+        trustedAbsolutePath = direct.admission === "identity";
+    }
+    else {
+        const canonical = admitRawPathInsideRoot(rootCanonicalPath, raw, params.rootIdentity);
+        const relative = canonical?.relativePath
             ?? rawPathRelativeToCanonicalRoot(raw, rootCanonicalPath, params);
         if (relative === undefined) {
             throw pathEscapeError({ rootPath, absolutePath: raw, boundaryLabel: params.boundaryLabel });
         }
-        raw = `${rootPath}${path.sep}${relative}`;
+        trustedAbsolutePath = canonical?.admission === "identity";
+        raw = relative === "" ? rootPath : `${rootPath}${path.sep}${relative}`;
     }
     return {
         params: raw === params.absolutePath ? params : { ...params, absolutePath: raw },
-        rootPath, rootCanonicalPath, absolutePath,
+        rootPath,
+        rootCanonicalPath,
+        // Preserve the caller-spelling receipt for ordinary aliases. Only a
+        // Windows case-fold admission must return the identity-gated Root spelling,
+        // because downstream I/O must not reuse the ambiguous caller prefix.
+        absolutePath: trustedAbsolutePath ? path.resolve(raw) : callerAbsolutePath,
     };
 }
 function sanitizeRootPathError(error) {
@@ -93,7 +106,7 @@ function assertNoEmbeddedDriveRelativeSegment(filePath, label) {
 }
 function createLexicalTraversalState(params) {
     const rawAbsolutePath = params.params.absolutePath;
-    const relative = rawPathRelativeToRoot(params.rootPath, rawAbsolutePath);
+    const relative = admitRawPathInsideRoot(params.rootPath, rawAbsolutePath, params.params.rootIdentity)?.relativePath;
     if (relative === undefined)
         throw new Error("Path traversal must begin at the root");
     const segments = splitTraversalSegments(relative);
@@ -124,7 +137,7 @@ function splitTraversalSegments(value) {
         segments.push(".");
     return segments;
 }
-function rawPathRelativeToRoot(rootPath, candidatePath) {
+function admitRawPathInsideRoot(rootPath, candidatePath, rootIdentity) {
     if (!path.isAbsolute(candidatePath)) {
         return undefined;
     }
@@ -132,30 +145,36 @@ function rawPathRelativeToRoot(rootPath, candidatePath) {
     const candidate = process.platform === "win32"
         ? candidatePath.replaceAll("/", path.sep)
         : candidatePath;
+    if (process.platform === "win32") {
+        return admitPathInsideRoot({ rootPath: root, candidatePath: candidate, rootIdentity });
+    }
     if (candidate === root) {
-        return "";
+        return { admission: "exact", path: candidate, relativePath: "" };
     }
     const rootWithSep = root.endsWith(path.sep) ? root : `${root}${path.sep}`;
     const candidatePrefix = candidate.slice(0, rootWithSep.length);
-    const prefixMatches = process.platform === "win32"
-        ? candidatePrefix.toLowerCase() === rootWithSep.toLowerCase()
-        : candidatePrefix === rootWithSep;
-    return prefixMatches ? candidate.slice(rootWithSep.length) : undefined;
+    return candidatePrefix === rootWithSep
+        ? {
+            admission: "exact",
+            path: candidate,
+            relativePath: candidate.slice(rootWithSep.length),
+        }
+        : undefined;
 }
 function assertLexicalCursorInsideBoundary(context, candidatePath) {
-    assertInsideBoundary({
+    return assertInsideBoundary({
         boundaryLabel: context.resolveParams.boundaryLabel,
         rootCanonicalPath: context.rootCanonicalPath,
+        rootIdentity: context.resolveParams.rootIdentity,
         candidatePath,
         absolutePath: context.absolutePath,
     });
 }
 function advanceCanonicalCursorForSegment(context, segment) {
-    context.state.canonicalCursor = path.resolve(context.state.canonicalCursor, segment);
-    assertLexicalCursorInsideBoundary(context, context.state.canonicalCursor);
+    context.state.canonicalCursor = assertLexicalCursorInsideBoundary(context, path.resolve(context.state.canonicalCursor, segment));
 }
 function finalizeLexicalResolution(context, kind) {
-    assertLexicalCursorInsideBoundary(context, context.state.canonicalCursor);
+    context.state.canonicalCursor = assertLexicalCursorInsideBoundary(context, context.state.canonicalCursor);
     return buildResolvedRootPath({
         absolutePath: context.absolutePath,
         canonicalPath: context.state.canonicalCursor,
@@ -181,15 +200,19 @@ function lexicalStatDisposition(params) {
     return params.allowFinalSymlink && params.isLast ? "break" : "resolve-link";
 }
 function applyResolvedSymlinkHop(context, linkCanonical) {
-    if (!isPathInside(context.rootCanonicalPath, linkCanonical)) {
+    let admitted;
+    try {
+        admitted = assertLexicalCursorInsideBoundary(context, linkCanonical);
+    }
+    catch {
         throw symlinkEscapeError({
             boundaryLabel: context.resolveParams.boundaryLabel,
             rootCanonicalPath: context.rootCanonicalPath,
             symlinkPath: context.state.lexicalCursor,
         });
     }
-    context.state.canonicalCursor = linkCanonical;
-    context.state.lexicalCursor = linkCanonical;
+    context.state.canonicalCursor = admitted;
+    context.state.lexicalCursor = admitted;
 }
 function applyParentTraversalStep(context) {
     context.state.lexicalCursor = path.resolve(context.state.lexicalCursor, "..");
@@ -380,8 +403,13 @@ function relativeInsideRoot(rootPath, targetPath) {
     return relative;
 }
 function assertInsideBoundary(params) {
-    if (isPathInside(params.rootCanonicalPath, params.candidatePath)) {
-        return;
+    const admitted = admitPathInsideRoot({
+        rootPath: params.rootCanonicalPath,
+        candidatePath: params.candidatePath,
+        rootIdentity: params.rootIdentity,
+    });
+    if (admitted) {
+        return admitted.path;
     }
     throw new Error(`Path resolves outside ${params.boundaryLabel} (${shortPath(params.rootCanonicalPath)}): ${shortPath(params.absolutePath)}`);
 }

package/dist/root-paths.d.ts

@@ -1,4 +1,5 @@
 import { FsSafeError } from "./errors.js";
+import { type ResolvePathWithinRootParams } from "./path-scope-lexical.js";
 type InvalidPathResult = {
     ok: false;
     error: string;
@@ -50,12 +51,7 @@ export type PathScope = {
         mode?: number;
     }): Promise<DirectoryResult>;
 };
-export declare function resolvePathWithinRoot(params: {
-    rootDir: string;
-    requestedPath: string;
-    scopeLabel: string;
-    defaultFileName?: string;
-}): {
+export declare function resolvePathWithinRoot(params: ResolvePathWithinRootParams): {
     ok: true;
     path: string;
 } | {

package/dist/root-paths.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"root-paths.d.ts","sourceRoot":"","sources":["../src/root-paths.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"root-paths.d.ts","sourceRoot":"","sources":["../src/root-paths.ts"],"names":[],"mappings":"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"}

package/dist/root-paths.js

@@ -5,19 +5,17 @@ import { formatErrorDetail } from "./error-detail.js";
 import { FsSafeError } from "./errors.js";
 import { assertNoNulPathInput, hasNodeErrorCode, isNodeError, isNotFoundPathError, isPathInside, isPathRelativeEscape, } from "./path.js";
 import { root as openRoot } from "./root.js";
+import { realpathSync } from "./realpath.js";
+import { resolvePathWithinNormalizedRoot } from "./path-scope-lexical.js";
 function invalidPath(scopeLabel) {
     return {
         ok: false,
         error: `Invalid path: must stay within ${scopeLabel}`,
     };
 }
-function pathStaysWithinRoot(rootDir, candidatePath) {
-    const relative = path.relative(rootDir, candidatePath);
-    return Boolean(relative) && !isPathRelativeEscape(relative);
-}
 async function resolveRealPathIfExists(targetPath) {
     try {
-        return fsSync.realpathSync.native(targetPath);
+        return realpathSync.native(targetPath);
     }
     catch {
         return undefined;
@@ -29,7 +27,7 @@ async function resolveTrustedRootRealPath(rootDir) {
         if (!rootLstat.isDirectory() || rootLstat.isSymbolicLink()) {
             return undefined;
         }
-        return fsSync.realpathSync.native(rootDir);
+        return realpathSync.native(rootDir);
     }
     catch {
         return undefined;
@@ -50,7 +48,7 @@ async function validateCanonicalPathWithinRoot(params) {
         if (params.expect === "file" && candidateLstat.nlink > 1) {
             return "invalid";
         }
-        const candidateRealPath = fsSync.realpathSync.native(params.candidatePath);
+        const candidateRealPath = realpathSync.native(params.candidatePath);
         return isPathInside(params.rootRealPath, candidateRealPath) ? "ok" : "invalid";
     }
     catch (err) {
@@ -58,23 +56,7 @@ async function validateCanonicalPathWithinRoot(params) {
     }
 }
 export function resolvePathWithinRoot(params) {
-    const root = path.resolve(params.rootDir);
-    const raw = params.requestedPath.trim();
-    if (!raw) {
-        if (!params.defaultFileName) {
-            return { ok: false, error: "path is required" };
-        }
-        const defaultPath = path.resolve(root, params.defaultFileName);
-        if (!pathStaysWithinRoot(root, defaultPath)) {
-            return { ok: false, error: `Invalid path: must stay within ${params.scopeLabel}` };
-        }
-        return { ok: true, path: defaultPath };
-    }
-    const resolved = path.resolve(root, raw);
-    if (!pathStaysWithinRoot(root, resolved)) {
-        return { ok: false, error: `Invalid path: must stay within ${params.scopeLabel}` };
-    }
-    return { ok: true, path: resolved };
+    return resolvePathWithinNormalizedRoot(params, path.resolve(params.rootDir));
 }
 export async function resolveWritablePathWithinRoot(params) {
     const lexical = resolvePathWithinRoot(params);
@@ -169,9 +151,9 @@ export async function ensureDirectoryWithinRoot(params) {
             return invalidPath(scopeLabel);
         }
         await assertNoSymlinkSegments({ rootDir, targetPath, scopeLabel });
-        const rootReal = fsSync.realpathSync.native(rootDir);
+        const rootReal = realpathSync.native(rootDir);
         const nearestExistingPath = await resolveNearestExistingPath(targetPath);
-        const nearestExistingReal = fsSync.realpathSync.native(nearestExistingPath);
+        const nearestExistingReal = realpathSync.native(nearestExistingPath);
         if (!isPathInside(rootReal, nearestExistingReal)) {
             return invalidPath(scopeLabel);
         }
@@ -202,12 +184,12 @@ export async function ensureDirectoryWithinRoot(params) {
                     }
                 }
             }
-            const currentReal = fsSync.realpathSync.native(current);
+            const currentReal = realpathSync.native(current);
             if (!isPathInside(rootReal, currentReal)) {
                 return invalidPath(scopeLabel);
             }
         }
-        const targetReal = fsSync.realpathSync.native(targetPath);
+        const targetReal = realpathSync.native(targetPath);
         if (!isPathInside(rootReal, targetReal)) {
             return invalidPath(scopeLabel);
         }
@@ -229,12 +211,22 @@ export async function ensureDirectoryWithinRoot(params) {
 }
 export function resolvePathsWithinRoot(params) {
     const resolvedPaths = [];
+    let previousRootDir;
+    let previousResolvedRoot = "";
     for (const raw of params.requestedPaths) {
-        const pathResult = resolvePathWithinRoot({
+        const request = {
             rootDir: params.rootDir,
             requestedPath: raw,
             scopeLabel: params.scopeLabel,
-        });
+        };
+        // Relative roots may follow cwd changes made by an input iterator or getter.
+        const resolvedRoot = process.platform !== "win32" && typeof request.rootDir === "string" &&
+            request.rootDir.startsWith("/") && request.rootDir === previousRootDir
+            ? previousResolvedRoot
+            : path.resolve(request.rootDir);
+        previousRootDir = request.rootDir;
+        previousResolvedRoot = resolvedRoot;
+        const pathResult = resolvePathWithinNormalizedRoot(request, resolvedRoot);
         if (!pathResult.ok) {
             return { ok: false, error: pathResult.error };
         }
@@ -309,7 +301,7 @@ async function resolveCheckedPathsWithinRoot(params, allowMissingFallback) {
             return lexicalPathResult;
         }
         try {
-            const resolvedExistingPath = fsSync.realpathSync.native(raw);
+            const resolvedExistingPath = realpathSync.native(raw);
             const relativePath = path.relative(rootRealPath, resolvedExistingPath);
             if (!isInRoot(relativePath)) {
                 return lexicalPathResult;
@@ -351,7 +343,7 @@ async function resolveCheckedPathsWithinRoot(params, allowMissingFallback) {
                         scopeLabel: params.scopeLabel,
                     });
                     const existingPath = await resolveNearestExistingPath(pathResult.fallbackPath);
-                    const existingRealPath = fsSync.realpathSync.native(existingPath);
+                    const existingRealPath = realpathSync.native(existingPath);
                     if (!isPathInside(rootRealPath, existingRealPath)) {
                         return invalidPath(params.scopeLabel);
                     }

package/dist/root-remove.d.ts

@@ -0,0 +1,5 @@
+import { type RootContext } from "./root-context.js";
+import type { RootRemoveOptions } from "./root-options.js";
+export declare function validateRemoveOptions(options: RootRemoveOptions): void;
+export declare function removePathInRootFallback(root: RootContext, targetPath: string, options: RootRemoveOptions): Promise<void>;
+//# sourceMappingURL=root-remove.d.ts.map

package/dist/root-remove.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"root-remove.d.ts","sourceRoot":"","sources":["../src/root-remove.ts"],"names":[],"mappings":"AAeA,OAAO,EAA6B,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAS3D,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,iBAAiB,GAAG,IAAI,CAgBtE;AA0CD,wBAAsB,wBAAwB,CAC5C,IAAI,EAAE,WAAW,EACjB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,IAAI,CAAC,CA6Lf"}