@vibe-agent-toolkit/utils 0.1.42 → 0.2.0-rc.10

package/dist/path-containment.d.ts

@@ -0,0 +1,64 @@
+/**
+ * `isUnderRoot` — the containment question a SINK asks.
+ *
+ * A delete, a copy, an uninstall: each takes a path that somebody else spelled
+ * (a manifest's `name:`, a `flatSkills` entry, a positional the user typed) and
+ * is about to act on `join(root, that)`. The question is whether the action
+ * lands inside the root, and the only honest answer comes from the
+ * filesystem: `startsWith('..')` on a lexical `relative()` misses a symlink
+ * inside the root that points out, refuses a member named `..cache`, and is
+ * blind to a drive letter — the sweep behind this module watched all three
+ * happen at exit 0.
+ *
+ * Both sides are canonicalized the same way, through the deepest existing
+ * ancestor, so a root reached through a symlink (macOS `/tmp`, a linked
+ * `~/.claude`) still contains its members, and a candidate that does not exist
+ * yet is judged by where creating it would land. Absence is reported as its
+ * own answer rather than folded into either side, because a delete sink and a
+ * create sink want opposite things from it.
+ *
+ * Lexical classification of an already-relative path — a projection identity,
+ * a report relativizer — is a different question with a different helper:
+ * `relativeEscapesRoot` in `path-core.ts`, which touches no filesystem.
+ */
+/**
+ * Where a candidate stands relative to a root, as the filesystem sees it.
+ *
+ * - `inside` — the candidate exists and its realpath is a STRICT descendant of
+ *   the root's realpath. A delete or copy may proceed.
+ * - `outside` — its realpath (or, when it does not exist, the realpath of its
+ *   deepest existing ancestor with the missing remainder re-appended) is not
+ *   under the root. The root itself is `outside` too: nothing is under itself,
+ *   and a sink that could delete its own root has no business here.
+ * - `absent` — nothing exists at the candidate, and creating it would land
+ *   inside the root. A create sink proceeds; a delete sink has nothing to do.
+ */
+export type Containment = 'inside' | 'outside' | 'absent';
+/**
+ * Is `candidate` strictly under `root`, as the filesystem judges it?
+ *
+ * Both paths may be relative (resolved from cwd) or absolute, in either
+ * separator; neither has to exist. See {@link Containment} for the three
+ * answers and which sinks accept which.
+ *
+ * ⚠️ Costs one `lstat` per missing component plus two `realpath`s. That is
+ * nothing for a sink — a delete or a copy dwarfs it — and too much for a loop
+ * over every link in a corpus, which is why the projection and link lanes
+ * classify lexically with `relativeEscapesRoot` and never call this.
+ *
+ * @param root - The directory the action must stay inside
+ * @param candidate - The path the action is about to touch
+ * @returns `'inside'`, `'outside'`, or `'absent'`
+ * @throws When the OS refuses to examine either path for any reason but
+ *   absence — a refusal is reported, never read as "not there"
+ *
+ * @example
+ * // A delete sink: only an existing, contained target may go.
+ * if (isUnderRoot(skillsDir, target) !== 'inside') throw new Error(`refusing to remove ${target}: not inside ${skillsDir}`);
+ * await rm(target, { recursive: true, force: true });
+ *
+ * // A create sink: absent-but-contained is exactly the happy path.
+ * if (isUnderRoot(skillsDir, dest) === 'outside') throw new Error(`refusing to install to ${dest}: not inside ${skillsDir}`);
+ */
+export declare function isUnderRoot(root: string, candidate: string): Containment;
+//# sourceMappingURL=path-containment.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"path-containment.d.ts","sourceRoot":"","sources":["../src/path-containment.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAQH;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG,SAAS,GAAG,QAAQ,CAAC;AAkD1D;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,WAAW,CAQxE"}

package/dist/path-containment.js

@@ -0,0 +1,111 @@
+/**
+ * `isUnderRoot` — the containment question a SINK asks.
+ *
+ * A delete, a copy, an uninstall: each takes a path that somebody else spelled
+ * (a manifest's `name:`, a `flatSkills` entry, a positional the user typed) and
+ * is about to act on `join(root, that)`. The question is whether the action
+ * lands inside the root, and the only honest answer comes from the
+ * filesystem: `startsWith('..')` on a lexical `relative()` misses a symlink
+ * inside the root that points out, refuses a member named `..cache`, and is
+ * blind to a drive letter — the sweep behind this module watched all three
+ * happen at exit 0.
+ *
+ * Both sides are canonicalized the same way, through the deepest existing
+ * ancestor, so a root reached through a symlink (macOS `/tmp`, a linked
+ * `~/.claude`) still contains its members, and a candidate that does not exist
+ * yet is judged by where creating it would land. Absence is reported as its
+ * own answer rather than folded into either side, because a delete sink and a
+ * create sink want opposite things from it.
+ *
+ * Lexical classification of an already-relative path — a projection identity,
+ * a report relativizer — is a different question with a different helper:
+ * `relativeEscapesRoot` in `path-core.ts`, which touches no filesystem.
+ */
+import { lstatSync } from 'node:fs';
+import path from 'node:path';
+import { isPathAbsentError } from './errors/errno.js';
+import { normalizePath, safePath, toForwardSlash } from './path-utils.js';
+/**
+ * The canonical spelling of `target`, from its deepest existing ancestor.
+ *
+ * Walks up until `lstat` answers, canonicalizes THAT with the same realpath
+ * every path helper uses, and re-appends the missing tail. A refusal is not
+ * an absence: `EACCES` on an ancestor, `ELOOP` on a cycle, an invalid name —
+ * the OS is saying it cannot examine the path, and a containment verdict
+ * built on the spelling it refused is the bug this module exists to remove.
+ * Those stay loud.
+ *
+ * `lstat` rather than `stat`, so a dangling symlink counts as existing: it is
+ * an entry the sink can act on (a delete removes the link), and its realpath
+ * failing is answered by {@link normalizePath} with the lexical spelling, which
+ * is where the entry is.
+ */
+function canonicalFromAncestor(target) {
+    const absolute = safePath.resolve(target);
+    const missing = [];
+    let candidate = absolute;
+    for (;;) {
+        if (entryExists(candidate)) {
+            return {
+                canonical: safePath.join(toForwardSlash(normalizePath(candidate)), ...missing),
+                exists: missing.length === 0,
+            };
+        }
+        const parent = toForwardSlash(path.dirname(candidate));
+        // Fixpoint at a filesystem root: `dirname` returns its own input, nothing
+        // on the path resolved, and the lexical form is the only answer there is.
+        if (parent === candidate) {
+            return { canonical: absolute, exists: false };
+        }
+        missing.unshift(path.basename(candidate));
+        candidate = parent;
+    }
+}
+/** Whether an entry (a file, a directory, or a link — dangling or not) is at `p`. */
+function entryExists(p) {
+    try {
+        lstatSync(p);
+        return true;
+    }
+    catch (error) {
+        if (isPathAbsentError(error))
+            return false;
+        throw error;
+    }
+}
+/**
+ * Is `candidate` strictly under `root`, as the filesystem judges it?
+ *
+ * Both paths may be relative (resolved from cwd) or absolute, in either
+ * separator; neither has to exist. See {@link Containment} for the three
+ * answers and which sinks accept which.
+ *
+ * ⚠️ Costs one `lstat` per missing component plus two `realpath`s. That is
+ * nothing for a sink — a delete or a copy dwarfs it — and too much for a loop
+ * over every link in a corpus, which is why the projection and link lanes
+ * classify lexically with `relativeEscapesRoot` and never call this.
+ *
+ * @param root - The directory the action must stay inside
+ * @param candidate - The path the action is about to touch
+ * @returns `'inside'`, `'outside'`, or `'absent'`
+ * @throws When the OS refuses to examine either path for any reason but
+ *   absence — a refusal is reported, never read as "not there"
+ *
+ * @example
+ * // A delete sink: only an existing, contained target may go.
+ * if (isUnderRoot(skillsDir, target) !== 'inside') throw new Error(`refusing to remove ${target}: not inside ${skillsDir}`);
+ * await rm(target, { recursive: true, force: true });
+ *
+ * // A create sink: absent-but-contained is exactly the happy path.
+ * if (isUnderRoot(skillsDir, dest) === 'outside') throw new Error(`refusing to install to ${dest}: not inside ${skillsDir}`);
+ */
+export function isUnderRoot(root, candidate) {
+    const rootReal = canonicalFromAncestor(root).canonical;
+    const target = canonicalFromAncestor(candidate);
+    const prefix = rootReal.endsWith('/') ? rootReal : `${rootReal}/`;
+    if (!target.canonical.startsWith(prefix)) {
+        return 'outside';
+    }
+    return target.exists ? 'inside' : 'absent';
+}
+//# sourceMappingURL=path-containment.js.map

package/dist/path-containment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-containment.js","sourceRoot":"","sources":["../src/path-containment.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACpC,OAAO,IAAI,MAAM,WAAW,CAAC;AAE7B,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAgB1E;;;;;;;;;;;;;;GAcG;AACH,SAAS,qBAAqB,CAAC,MAAc;IAC3C,MAAM,QAAQ,GAAG,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAC1C,MAAM,OAAO,GAAa,EAAE,CAAC;IAC7B,IAAI,SAAS,GAAG,QAAQ,CAAC;IACzB,SAAS,CAAC;QACR,IAAI,WAAW,CAAC,SAAS,CAAC,EAAE,CAAC;YAC3B,OAAO;gBACL,SAAS,EAAE,QAAQ,CAAC,IAAI,CAAC,cAAc,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,EAAE,GAAG,OAAO,CAAC;gBAC9E,MAAM,EAAE,OAAO,CAAC,MAAM,KAAK,CAAC;aAC7B,CAAC;QACJ,CAAC;QACD,MAAM,MAAM,GAAG,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC;QACvD,0EAA0E;QAC1E,0EAA0E;QAC1E,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;YACzB,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC;QAChD,CAAC;QACD,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC;QAC1C,SAAS,GAAG,MAAM,CAAC;IACrB,CAAC;AACH,CAAC;AAED,qFAAqF;AACrF,SAAS,WAAW,CAAC,CAAS;IAC5B,IAAI,CAAC;QACH,SAAS,CAAC,CAAC,CAAC,CAAC;QACb,OAAO,IAAI,CAAC;IACd,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,iBAAiB,CAAC,KAAK,CAAC;YAAE,OAAO,KAAK,CAAC;QAC3C,MAAM,KAAK,CAAC;IACd,CAAC;AACH,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,UAAU,WAAW,CAAC,IAAY,EAAE,SAAiB;IACzD,MAAM,QAAQ,GAAG,qBAAqB,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC;IACvD,MAAM,MAAM,GAAG,qBAAqB,CAAC,SAAS,CAAC,CAAC;IAChD,MAAM,MAAM,GAAG,QAAQ,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,QAAQ,GAAG,CAAC;IAClE,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC;QACzC,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC;AAC7C,CAAC"}

package/dist/path-core.d.ts

@@ -10,6 +10,26 @@
  * `mkdirSyncReal`, `resolveFromImportMeta`, `dynamicImportPath`) live in
  * `./path-utils.ts` and are exposed via the `./fs` entry.
  */
+import { VatError } from './errors/vat-error.js';
+/**
+ * Thrown by {@link safePath.joinUnderRoot} when the joined path would land
+ * outside its root.
+ *
+ * A class with a code rather than a prefixed sentence: three packages used to
+ * recognise this refusal with `error.message.startsWith('safePath.joinUnderRoot:')`,
+ * which is a contract on prose. Dispatch with
+ * `isVatError(error, PathEscapesRootError.code)` — it survives the `src`/`dist`
+ * boundary that `instanceof` does not.
+ */
+export declare class PathEscapesRootError extends VatError {
+    /** The code every instance carries, for `isVatError(error, PathEscapesRootError.code)`. */
+    static readonly code = "PATH_ESCAPES_ROOT";
+    /**
+     * @param root - The root the path had to stay under
+     * @param detail - Which segment, or which result, escaped it
+     */
+    constructor(root: string, detail: string);
+}
 /**
  * Check if a path is absolute
  *
@@ -44,8 +64,9 @@ export declare function isAbsoluteAnyPlatform(p: string): boolean;
 /**
  * True if `p` contains a `..` parent-directory traversal segment.
  *
- * Forward-slash-normalized, then inspects each `/`-delimited segment — so a
- * `..` is caught regardless of the original OS separator. A containment guard
+ * Backslashes are read as separators on every host (the input is author-written
+ * config), then each `/`-delimited segment is inspected — so a `..` is caught
+ * regardless of the separator the author typed. A containment guard
  * for config-supplied relative paths (skill `files:` dest values, glob magic
  * remainders) that must never climb above their anchor directory.
  *
@@ -56,13 +77,66 @@ export declare function isAbsoluteAnyPlatform(p: string): boolean;
  * hasParentTraversalSegment('a..b/c')      // false (".." must be a whole segment)
  */
 export declare function hasParentTraversalSegment(p: string): boolean;
+/**
+ * True when a root-relative path — as `safePath.relative(root, p)` spells it —
+ * names something the root does not contain.
+ *
+ * The three shapes `path.relative` can return for an outsider: the parent
+ * itself (`..`), a climb through it (`../x`), and, on Windows only, an
+ * absolute path (a target on another drive has no relative spelling). A name
+ * that merely BEGINS with two dots (`..notes.md`) is a member and reads as one;
+ * the bare `startsWith('..')` this replaces refused it, dropped the file from
+ * the package and unlinked the reference, at exit 0.
+ *
+ * ⚠️ **Lexical, on purpose.** This classifies a relative path that was already
+ * computed; it does not ask the filesystem, so a symlink inside the root that
+ * points outside reads as inside here. That is the right answer for the
+ * callers that own no root to ask about — a projection identity, a permission
+ * pattern, a report relativizer — and the WRONG one for a delete or copy sink,
+ * which must ask {@link isUnderRoot} from `@vibe-agent-toolkit/utils` instead.
+ * The empty relative (the root itself) is not an escape; whether equality is
+ * acceptable is the caller's question and is asked beside this one.
+ *
+ * @param normalizedRelative - A forward-slashed root-relative path
+ * @returns True when the root does not contain it
+ *
+ * @example
+ * relativeEscapesRoot(safePath.relative(root, p))   // the whole idiom
+ * relativeEscapesRoot('../x')       // true
+ * relativeEscapesRoot('..notes.md') // false — a member whose name starts with dots
+ */
+export declare function relativeEscapesRoot(normalizedRelative: string): boolean;
+/**
+ * True when `name` can only ever be ONE directory entry under whatever it is
+ * joined to: non-empty, not `.` or `..`, no separator of either platform, no
+ * NUL, no drive-letter prefix.
+ *
+ * The check for a caller-controlled NAME — a skill name from a manifest, a
+ * session id, a positional the user typed — that is about to become
+ * `join(root, name)`. A name is not a path: `..cache` and `a..b` are legitimate
+ * entries, and `includes('..')` refused them while `startsWith` let `x/../..`
+ * through. The question is whether the join can land anywhere but directly
+ * under `root`, and that is answered by the segment's shape alone, with no
+ * filesystem — which is also why this belongs beside the path helpers rather
+ * than beside {@link isUnderRoot}, which is the check for a PATH.
+ *
+ * @param name - The proposed entry name
+ * @returns True when `join(root, name)` is a direct child of `root`
+ *
+ * @example
+ * isSingleFsSegment('my-skill')   // true
+ * isSingleFsSegment('..cache')    // true — dots inside a name are just dots
+ * isSingleFsSegment('../victim')  // false
+ * isSingleFsSegment('..')         // false
+ */
+export declare function isSingleFsSegment(name: string): boolean;
 /**
  * Compute a `ValidationIssue.location`: an absolute source file path made
  * relative to the scan/project root, forward-slashed.
  *
  * This is the ONE relativizer every VAT validation lane uses. `location` is
  * contractually project-relative (see `ValidationIssue` in
- * `@vibe-agent-toolkit/agent-schema`), so producers must route through here
+ * `@vibe-agent-toolkit/schema`), so producers must route through here
  * rather than emitting `skillPath` directly — absolute locations leak the
  * developer's home directory into CI logs and make `validation.allow` globs,
  * which match against `location`, unwritable.
@@ -115,33 +189,84 @@ export declare function toAbsolutePath(p: string, baseDir: string): string;
  */
 export declare function getRelativePath(from: string, to: string): string;
 /**
- * Convert a path to forward slashes
+ * Convert a NATIVE path — one the filesystem, `path.*`, `readdir` or git
+ * handed you — to forward slashes.
  *
- * Windows accepts both forward slashes and backslashes as path separators.
- * This function normalizes all paths to use forward slashes for consistency.
- * Useful for glob pattern matching, cross-platform comparisons, and string operations.
+ * Converts only where a backslash is a separator (win32). On POSIX a backslash is a
+ * legal filename character, so `docs/x\y.md` is one file and is returned
+ * unchanged: converting it would invent a phantom `docs/x/` directory and, in
+ * {@link safePath.joinUnderRoot}, turn an `x\..\..` NAME into a climb.
  *
- * @param p - Path to convert
- * @returns Path with forward slashes
+ * For AUTHOR-WRITTEN text — an href, a glob, a config value, a CLI argument,
+ * an archive entry name — whose backslashes must read as separators on every
+ * host, use {@link toForwardSlashAnyPlatform}.
  *
- * @example
- * toForwardSlash('C:\\Users\\docs\\README.md')
- * // Returns: 'C:/Users/docs/README.md'
+ * @param p - A native path
+ * @returns The path with forward slashes (identity on POSIX)
  *
- * toForwardSlash('/project/docs/README.md')
- * // Returns: '/project/docs/README.md' (unchanged)
+ * @example
+ * toForwardSlash('C:\\Users\\docs\\README.md') // win32: 'C:/Users/docs/README.md'
+ * toForwardSlash('docs/x\\y.md')                // POSIX: 'docs/x\\y.md' (unchanged)
  */
 export declare function toForwardSlash(p: string): string;
+/**
+ * Convert every backslash to a forward slash, on every host.
+ *
+ * For AUTHOR-WRITTEN text that may carry Windows spellings regardless of where
+ * VAT runs — markdown hrefs, globs, config values, CLI arguments, zip entry
+ * names — and for containment guards that must refuse `..\x` everywhere.
+ * Never use it on a path read from the filesystem or git: on POSIX that
+ * backslash is part of a filename. Use {@link toForwardSlash} for those.
+ *
+ * @param text - Author-written path text
+ * @returns The text with every backslash replaced by `/`
+ *
+ * @example
+ * toForwardSlashAnyPlatform('..\\evil')   // '../evil' on every host
+ */
+export declare function toForwardSlashAnyPlatform(text: string): string;
+/**
+ * Normalize text to Unicode NFC — the form in which two *visually identical*
+ * filenames compare equal.
+ *
+ * `é` has two encodings: precomposed NFC (`U+00E9`) and decomposed NFD
+ * (`e` + `U+0301`). They render identically and name the same file, yet they are
+ * different strings, so `===`, `toLowerCase()`, `Map.get()` and `Set.has()` all
+ * report them as different. `readdir` hands back whichever form is on disk —
+ * APFS preserves what was written, and decomposed names are common on macOS —
+ * while a markdown link typed in an editor almost always carries the composed
+ * form. The two sides of a filename comparison therefore disagree about a file
+ * that plainly exists.
+ *
+ * ⚠️ **This produces a COMPARISON KEY, never a path to open.** Do not normalize
+ * a path on its way to `fs.*`. macOS would not notice — it is
+ * normalization-*insensitive* at the syscall level, so `existsSync` answers the
+ * same for either form — but Linux is not: on ext4 the two forms are simply
+ * different byte sequences naming different files, so opening the normalized
+ * form of a decomposed filename fails outright. That asymmetry is exactly why
+ * this is not folded into {@link safePath.resolve}: its output is handed
+ * straight to the filesystem. Normalize where two strings are *compared*, and
+ * leave the string the filesystem receives alone.
+ *
+ * @param value - A filename, path segment, or whole path
+ * @returns The same text in NFC. Pure ASCII is returned unchanged.
+ *
+ * @example
+ * toNfc('cafe\u0301.md') === toNfc('caf\u00e9.md')  // true — same file, two encodings
+ */
+export declare function toNfc(value: string): string;
 /**
  * Cross-platform safe path operations.
  *
  * Wraps Node's `path.join()`, `path.resolve()`, and `path.relative()` to always
- * return forward-slash paths. On Windows, the native `path.*` functions return
+ * return forward-slash paths (converted through {@link toForwardSlash}, so a
+ * backslash inside a POSIX filename survives). On Windows, the native `path.*` functions return
  * backslashes, which causes bugs when paths are used as Map keys, compared as
  * strings, or matched with glob patterns.
  *
  * **Use these instead of importing from `node:path` directly.**
- * ESLint rules enforce this — see `no-path-join`, `no-path-resolve`, `no-path-relative`.
+ * An ESLint rule enforces this — see `no-raw-node-path` (its `functions` option
+ * table maps each of `join`/`resolve`/`relative` to its `safePath.*` replacement).
  *
  * @example
  * ```typescript
@@ -152,7 +277,7 @@ export declare function toForwardSlash(p: string): string;
  * safePath.resolve('/project', './docs')                   // → '/project/docs'
  * safePath.relative('/project/docs', '/project')           // → '..'
  * safePath.joinUnderRoot('/harness', 'skill-abc')          // → '/harness/skill-abc'
- * safePath.joinUnderRoot('/harness', '../escape')          // throws Error
+ * safePath.joinUnderRoot('/harness', '../escape')          // throws PathEscapesRootError
  * ```
  */
 export declare const safePath: {
@@ -180,7 +305,7 @@ export declare const safePath: {
      * skill-test staging code was vulnerable to on Windows.
      *
      * @returns Forward-slash absolute path guaranteed to be inside `root`.
-     * @throws {Error} If the resolved path would escape `root`.
+     * @throws {PathEscapesRootError} If the resolved path would escape `root`.
      *
      * @example
      * ```typescript

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

@@ -1 +1 @@
-{"version":3,"file":"path-core.d.ts","sourceRoot":"","sources":["../src/path-core.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAEjD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAExD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAE5D;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,aAAa,CAAC,cAAc,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAEjF;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAKjE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAMhE;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAEhD;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,QAAQ;IACnB,6DAA6D;8BAC9C,MAAM,EAAE,KAAG,MAAM;IAIhC,gEAAgE;iCAC9C,MAAM,EAAE,KAAG,MAAM;IAInC,iEAAiE;8BAClD,MAAM,MAAM,MAAM,KAAG,MAAM;IAI1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;mCACiB,MAAM,eAAe,MAAM,EAAE,KAAG,MAAM;CAuClD,CAAC"}
+{"version":3,"file":"path-core.d.ts","sourceRoot":"","sources":["../src/path-core.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAEjD;;;;;;;;;GASG;AACH,qBAAa,oBAAqB,SAAQ,QAAQ;IAChD,2FAA2F;IAC3F,MAAM,CAAC,QAAQ,CAAC,IAAI,uBAAuB;IAE3C;;;OAGG;gBACS,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;CAGzC;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAEjD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAExD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAG5D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,mBAAmB,CAAC,kBAAkB,EAAE,MAAM,GAAG,OAAO,CAGvE;AAKD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAUvD;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,aAAa,CAAC,cAAc,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAEjF;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAKjE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAMhE;AAKD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAEhD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAG9D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE3C;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,QAAQ;IACnB,6DAA6D;8BAC9C,MAAM,EAAE,KAAG,MAAM;IAIhC,gEAAgE;iCAC9C,MAAM,EAAE,KAAG,MAAM;IAInC,iEAAiE;8BAClD,MAAM,MAAM,MAAM,KAAG,MAAM;IAI1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;mCACiB,MAAM,eAAe,MAAM,EAAE,KAAG,MAAM;CAiClD,CAAC"}