@mangos/filepath 0.0.8 → 1.0.0

package/README.md

@@ -1,283 +1,226 @@
 
-# filepath
+<h1>filepath tokenizer</h1>
 
-This is a filepath parsing _(LL(1) parser)_ and manipulation tool. It returns a parse tree describing the file path.
+<h2 id="synopsis">Synopsis</h2>
 
-- joins lexed path names
-- infer the most likely OS file type(s) (plural) based on file name only.
-- validates path strings, (checks for forbidden characters.. etc)for the various os filetypes
+_Part of the monorepo [mangos][mangos-mono-repo]_
 
-FilePath tool complements the nodejs `path` module, parsing the following path types.
+- Tokenizes filepath string into its consituants;
+- Preserves correctly (node `resolve` does not) the root of _dos device path_ and _unc path_.
+- Provides utilities to work with different path types irrespective of OS used.
 
-_Part of the monorepo [mangos][mango-mono-repo]_
+<h2 id="supported-path">Supported Paths</h2>
 
-_Support the work by starring this [repo](https://github.com/R-js/mangos) on github._
+- [Microsoft dos device path][ddp]
+- [UNC path][unc]
+- [Traditional DOS path][tdp]
+- [Unix path][posix]
 
+<h2 id="ddp-failure">Node <code>resolve</code> does not preserve root of <a href="https://docs.microsoft.com/en-us/dotnet/standard/io/file-path-formats#dos-device-paths"<i>DOS Device Path</i></a></h2>
 
-It handles the following paths types:
+_Note: `\` needs to be escaped when using it in js code._
 
-| path type    | description                                                                                  |
-| ------------ | -------------------------------------------------------------------------------------------- |
-| `unc`        | microsoft unc filepath                                                                       |
-| `dos`        | traditional dos path (tdp) path                                                              |
-| `devicePath` | dos device path (ddp), alos allowing for dos devicepath descibing UNC `//./UNC/Server/Share` |
-| `posix`      | posix path                                                                                   |
-
-
-Works in browser and in node.
+```javascript
+// node  
+> path.resolve('\\\\?\\C:\\repos','../../../text.txt');
+// -> \\?\text.txt  \\?\C: is mangled
 
-```bash
-npm install @mangos/filepath
+// filePath
+> fp.resolve('\\\\?\\C:\\repos','../../../text.txt').toString();
+// -> '\\?\C:\text.txt'  aka'\\?\C:\' root is preserved
 ```
 
-`filepath` module has 3 named exports.
+<h2 id="unc-failure"> Node <code>resolve</code> does not (always) preserve root of <a href="https://learn.microsoft.com/en-us/dotnet/standard/io/file-path-formats#unc-paths"><i>UNC Path</i></a></h2>
+
+_Note: `\` needs to be escaped when using it in js code._
 
 ```javascript
-const {  inferPathType, lexPath,  resolve } = require('@mangos/filepath');
+// node resolve
+path.resolve('//?/UNC/Server/share', '../../../txt');
+// -> ''\\\\?\\txt''  mangled unc loot
 
-// rest of your code
+// this library
+filePath.resolve('//?/UNC/Server/share', '../../../txt').toString();
+// -> '\\\\?\\UNC\\Server\\share\\txt'  unc root preserved
+// -> root: \\\\?\\UNC\\Server\\share
+
+path.resolve('//system07/c$/x/y', '../../../../../txt');
+// -> '\\\\system07\\c$\\txt' unc root preserved 
+
+fp.resolve('//system07/c$/x/y', '../../../../../txt').toString()
+// -> '\\\\system07\\c$\\txt' unc root is preserved
 ```
 
-| function        | description                                                                           |
-| --------------- | ------------------------------------------------------------------------------------- |
-| `inferPathType` | guess the os file type based on the path string purely, multiple matches are possible |
-| `lexPath`       | lexer for path string, returns token array representing the path value                |
-| `resolve`       | akin to nodejs `path.resolve`, respecting `unc` , `unc_long` and `device path` roots  |
+<h2 id="api">Api</h2>
 
+<h3 id="api-overview">Overview</h3>
 
-## `inferPathType(path[, options])`
+There are 4 exported functions:
 
-- `path` [string][string] File path
-- `options` [Object][object]
-    - **unc**: [boolean][boolean] default will be set the the value of `platform === 'win32'`. If true, interperet the path as a unc pathname, if this is not possibe, `lexPath` returns undefined.
-    - **dos**: [boolean][boolean] default will be set to the value of  `platform === 'win32'`. If true,interperet as a TDP (Traditional Dos Path), if not possible, `lexPath` returns undefined.
-    - **devicePath**: [boolean][boolean] default will be set to value of `platform === 'win32'`. If true, interperet as DDP (Dos Device Path).
-    - **posix**: [boolean][boolean] default will be set to value of `platform !== 'win32'`. If true,interpret a UNIX devivce path.
-- Returns: [iterator < PathObject >](#pathobject) an Iterator returning valid interpretations (plural) of the `path` the most likely file types first.
+```typescript
+import { allPath, firstPath, resolve, resolvePathObject } from '@mangos/filepath';
+```
 
-```javascript
-const { inferPathType } = require('@mangos/filepath');
-
-const iterator = inferPathType('\\\\?\\unc\\c:/Users'); // Note: in JS you need to escape backslashes \\
-
-let value, done;
-
-{ value, done } = iterator.next(); // most likely path type
-//-> done = undefined.
-//-> value =
-/*
-{
-    type: "devicePath",
-    path: [ 
-            { 
-              token: '\u0005',  // token for the root element of a "devicePath" 
-              value: '\\\\?\\UNC\\c:\\Users',  //-> normalized path
-              start: 0,
-              end: 15 
-            } 
-          ] 
-} 
-*/
-{ value, done } = iterator.next(); // less likely type path
-// -> next possible interpretation for the string
+Most of the time you will be using `resolve`, `firstPath`.
+
+<h3 id="infer-path-options">Type <code>InferPathOptions</code></h3>
+
+The functions `allPath` and `firstPath` will try to tokenize a path string based on options object specified as the second argument.
+
+```typescript
+type InferPathOptions = {
+    devicePath: boolean; // parse string as dos device path
+    unc: boolean; // parse string as unc path
+    dos: boolean; // parse string as traditional dos path
+    posix: boolean; // parse string as unix path
+}
 ```
 
-## `lexPath([path[,options]])`
+Multiple path types _can_ be tokenized from the same path string.
 
-`LexPath` chooses the most likely (even if there are more interpertations of the `path` arguments) path type interpretation.
+The response of `allPath` will be an **array** of `ParsedPath` **or/and** `ParsedPathError` class instance, representing parsing for multiple OS path types.
 
-- `path` [string][string] File path.
-- `options` [Object][object]
-    - **unc**: [boolean][boolean] default will be set the the value of `platform === 'win32'`. If true, interperet the path as a unc pathname, if this is not possibe, `lexPath` returns undefined.
-    - **dos**: [boolean][boolean] default will be set to the value of  `platform === 'win32'`. If true,interperet as a TDP (Traditional Dos Path), if not possible, `lexPath` returns undefined.
-    - **devicePath**: [boolean][boolean] default will be set to value of `platform === 'win32'`. If true, interperet as DDP (Dos Device Path).
-    - **posix**: [boolean][boolean] default will be set to value of `platform !== 'win32'`. If true,interpret a UNIX devivce path.
-- Returns: single Object of type [PathObject](#pathobject). 
+<h4 id="infer-path-options-defaults">defaults:</h4>
 
+If <code><a href="#infer-path-options">InferpathOptions</code></a></code> argument is left empty in <a href="#fn-all-path"><code>allPath</code></a> and <a href="#fn-first-path"><code>firstPath</code></a> the default will be used based on OS:
 
-Example 1:
 
-```javascript
-const { lexPath } = require('@mangos/filepath');
-
-const result = lexPath('c:/hello/world'); // the function is agnostic to '\' or '/' tokens
-// ->
-/*
-{ path:
-   [ { token: '\u0003', value: 'c:', start: 0, end: 1 },   
-     { token: '\u0001', start: 2, end: 2, value: '\\' },   
-     { token: '\u0006', start: 3, end: 7, value: 'hello' },
-     { token: '\u0001', start: 8, end: 8, value: '\\' },
-     { token: '\u0006', start: 9, end: 13, value: 'world' } ],
-  type: 'dos' 
-*/
-```
+- The default for windos: `{ dos: true, devicePath: true, unc: true, posix: false }`
+- The default for unix: `{ posix: true }`
 
-Example 2:
+<h3 id="parsed-path"><code>ParsedPath</code> object</h3>
 
-```javascript
-const { lexPath } = require('@mangos/filepath');
-
-const result = lexPath('//Server1/share/file.txt'); // the function is agnostic to '\' or '/' tokens
-// ->
-/*
-{ 
-    type: 'unc',
-    path: [ 
-        { token: '\u0004', value: '\\\\Server1\\share', start: 0, end: 14 },
-        { token: '\u0001', start: 15, end: 15, value: '\\' },
-        { token: '\u0006', start: 16, end: 23, value: 'file.txt' } 
-   ]
-}
-*/
-```
+The response of a successfull path tokenization will be an ADT: `ParsedPath`.
 
-## `resolve([...paths])`
- 
-Resolve will work exactly like `path.resolve` but with these difference: It will respect the `devicePath` roots including the `Server` and `share` parts aswell. aka `//./unc/server/share` will seen as a root in totality.
+An instance of `ParsedPath` has the following fields/members
 
-- `...paths` [string][string] A sequence of file path or paths segments, the sequence can be empty (returns current working directory)
-- Returns: Object of [PathObject](#pathobject). 
+- members:
+    - `toString(): <string>`: return the original path string
+    - `isRelative(): <boolean>`: is the a path a relative one?
+- fields:
+    - `type: <string>`, one of the value `devicePath`, `unc`, `dos`, `posix`.
+    - `path: <Token[]>`, the path tokenized.
 
-Example 1:
+<h3 id="parsed-path-error"><code>ParsedPathError</code> object</h3>
 
-```javascript
-const { resolve } = require('@mangos/filepath');
-
-const result = resolve('//./unc/Server1/share1/dir1/file.txt','../../../../hello/world');
-//->
-/*
-{ path:
-   [ { token: '\u0005',
-       value: '\\\\?\\UNC\\Server1\\share1',
-       start: 0,
-       end: 21 },
-     { token: '\u0001', start: 22, end: 22, value: '\\' },
-     { token: '\u0006', start: 23, end: 39, value: 'hello' },
-     { token: '\u0001', start: 40, end: 40, value: '\\' },
-     { token: '\u0006', start: 41, end: 63, value: 'world' } ],
-  type: 'devicePath' }
-*/
-```
+If a path has illigal characters or is invalid the result of a tokenization will be an ADT: `ParsedPathError`
 
-Example 2:
+- members:
+    - `toString(): <string>`: algamation of all errors found during parsing.
+- attributes:
+    - `type: <string>`, one of the values `devicePath`, `unc`, `dos`, `posix`.
+    - `path: <Token[]>`, the path tokenized.
 
-```javascript
-const { resolve, lextPath } = require('@mangos/filepath');
-
-const posixPath = lexPath('/home/user1', {posix: true});
-
-const result = resolve('//./Server1/share1/',posixPath); // the last asbolute Path defines resulting pathType
-//->
-/*
-{ path:
-   [ { token: '\u0002', start: 0, end: 0, value: '/' },
-     { token: '\u0006', start: 1, end: 4, value: 'home' },
-     { token: '\u0001', start: 5, end: 5, value: '/' },
-     { token: '\u0006', start: 6, end: 10, value: 'user1' } ],
-  type: 'posix' }
-*/
+
+<h3 id="path-type-order-of-evaluation">Path type order of evaluation</h4>
+
+When a string is parsed it will be evaluated according to path types in the following order:
+
+1. `devicePath` tokanization will be tried first (if the `devicePath` boolean is set to true).
+2. `unc` tokanization will be tried second, (if the `devicePath` boolean is set to true).
+3. `dos` tokanization will be tried third, (if the `dos` boolean is set to true).
+4. `posix` tokanization will be tried forth, (if the `posix` boolean is set to true)
+
+<h3 id="api-functions">Functions</h3>
+
+<h4 id="fn-all-path">function: <code>allPath</code></h4>
+
+```typescript
+function allPath(path = '', options: InferPathOptions = {}): (ParsedPath | ParsedPathError)[];
 ```
 
-Example 3:
+<h5 id="fn-all-path-arguments">Arguments:</h5>
 
-```javascript
-const { resolve, lextPath } = require('@mangos/filepath');
-
-const posix = lexPath('/home/user1', {posix: true});
-const dos= lexPath('c:/Program Files/app');
-
-const result = resolve(dos,posi); // the last asbolute Path defines resulting pathType
-//->
-/*
-{ path:
-   [ { token: '\u0002', start: 0, end: 0, value: '/' },
-     { token: '\u0006', start: 1, end: 4, value: 'home' },
-     { token: '\u0001', start: 5, end: 5, value: '/' },
-     { token: '\u0006', start: 6, end: 10, value: 'user1' } ],
-  type: 'posix' }
-*/
+- <code>path: <i>string</i> optional</code>: (<b>Default</b> is current working directory). Relative or absolute <code>path</code> conforming to one of the <a href="#supported-path">supported path types</a>. Parsed according to <a href="#infer-path-options">options</a>. 
+- <code>options: <a href="infer-path-options">InferPathOptions</a> optional</code>: Parsing limited to flags set to <code>true</code> in <a href="#infer-path-options">options</a>.
+
+<h5 id="fn-all-path-return">Return:</h5>
+
+- An Array that is:
+    - empty (<code>path</code> is not one of the <a href="#supported-path">path types</a>)
+    - contains <a href="#parsed-path"><code>ParsedPath</code></a> and in case of errors <a href="#parsed-path-error"><code>ParsedPathError</code></a> objects. 
+
+<h5 id="fn-all-path-examples">Examples:</h5>
+
+```typescript
+import { allPath  } from '@mangos/filepath';
+
+// will attempt to tokenize the path according to dos and unc path types
+const paths = allPath('//system07/c$/x/y', { dos: true, unc: true });
+
+// unc is the only possible match
+paths.length
+// -> 1
+paths[0].type
+// -> unc
+path[0].toString()
+// -> \\system07\c$\x\y or '\\\\system07\\c$\\x\\y' with \ escaped
 ```
 
-Example 4:
+<h4 id="fn-first-path">function: <code>firstPath</code></h4>
 
-```javascript
-const { resolve } = require('@mangos/filepath');
-
-// current working directory is "/home/user1" (on a posix filesystem)
-const result = resolve('h1','h2');
-//->
-/*
-{ path:
-   [{ token: '\u0002', start: 0, end: 0, value: '/' },
-    { token: '\u0006', start: 1, end: 4, value: 'home' },
-    { token: '\u0001', start: 5, end: 5, value: '/' },
-    { token: '\u0006', start: 6, end: 10, value: 'user1' },
-    { token: '\u0001', start: 11, end: 11, value: '/' },
-    { token: '\u0006', start: 12, end: 13, value: 'h1' },
-    { token: '\u0001', start: 14, end: 14, value: '/' },
-    { token: '\u0006', start: 15, end: 16, value: 'h2' }
-],
- type: 'posix' }
-*/
+```typescript
+function firstPath(path = '', options: InferPathOptions = {}): ParsedPath | ParsedPathError | undefined;
 ```
 
-## Types
+<h5 id="fn-first-path-arguments">Arguments:</h5>
 
-### `Token-ID`
+- <code>path: <i>string</i> optional</code>: (<b>Default</b> is current working directory). Relative or absolute <code>path</code> conforming to one of the <a href="#supported-path">supported path types</a>. Parsed according to <a href="#infer-path-options">options</a>. 
+- <code>options: <a href="infer-path-options">InferPathOptions</a> optional</code>: Parsing limited to flags set to <code>true</code> in <a href="#infer-path-options">options</a>.
 
-The path lexer produces pieces of the string filepath as tokens, this is a list of all the lexer tokens
+<h5 id="fn-all-path-return">Return:</h5>
 
-| token      | value (token id) | descriptions                                  | example                                            |
-| ---------- | ---------------- | --------------------------------------------- | -------------------------------------------------- |
-| SEP        | `\u0001`         | filepath seperator                            | `/` or `\`                                         |
-| POSIX_ROOT | `\u0002`         | a posix root `/` at the beginning of a path   |                                                    |
-| TDP_ROOT   | `\u0003`         | root of a traditional dos path                | `c:`                                               |
-| UNC_ROOT   | `\u0004`         | root token for a UNC root                     | `//server1/share1` or `\\server|\share1`           |
-| DDP_ROOT   | `\u0005`         | dos device root                               | `\\?\unc\server1\share1` or `\\.\\c:` or `\\.\COM` |
-| PATHELT    | `\u0006`         | directory/file name between to `SEP`          |                                                    |
-| PARENT     | `\u0007`         | a PATHELT representing a PARENT directory     | `..`                                               |
-| CURRENT    | `\u0008`         | a PATHELT representing the current director i | `.`                                                |
+- <code>undefined</code>: The path was not confirm to any of the types listed in <a href="#supported-path">path types</a>
 
+- <a href="#parsed-path"><code>ParsedPath</code></a>: In case of successfull parse.
 
-### `Token`
+- <a href="#parsed-path-error"><code>ParsedPathError</code></a>: In case of legal structure but illegal characters in the path.
 
-This Token is the result of a lexer slicing and dicing a the a string representing a path
+
+<h4 id="fn-resolve-path-objects">function: <code>resolvePathObject</code></h4>
 
 ```typescript
-interface Token {
-    value: string; // a sanatized value of this token
-    start: number; // the index of original string, indicating the start of the token
-    end: number; //  the index of original string, indicating the end (inclusive) of the token
-    error: string; // it this token contains errors (like forbidden charactes in dos paths)
-    token: string; // single character `\u0001` between `\u0008`
-}
+function resolvePathObject(from: ParsedPath, ...toFragments: string[]): ParsedPath | ParsedPathError;
 ```
 
-For the `token` values, see this [list](#token-id)
+<h5 id="fn-resolve-path-objects-arguments">Arguments:</h5>
+
+- <code>from: <a  href="#parsed-path">ParsedPath</a></code>: A previously created <code><a  href="#parsed-path">ParsedPath</a></code> object via <code><a href="#fn-first-path">firstPath</a></code> function. 
+- <code>toFragments: <i>string[]</i></code>: A sequence of paths or path segments.
+
+<h5 id="fn-resolve-path-objects-return">Return:</h5>
+
+- <a href="#parsed-path"><code>ParsedPath</code></a>: In case of successfull resolve.
+- <a href="#parsed-path-error"><code>ParsedPathError</code></a>: In case of legal structure but illegal characters in the `from` or `toFragments`.
+
+<h5 id="fn-resolve-path-objects-throws">throws:</h5>
 
-### `PathObject`
+If <code>from</code> is a <a href="#parsed-path-error"><code>ParsedPathError</code></a> an `Error` will be thrown.
 
-- The function [inferPathType](#inferpathtypepath-options) returns an iterator of PathObject
-- The function [lexPath](#lexpathpathoptions) returns a single instance of `PathObject`
+<h4 id="fn-resolve">function: <code>resolve</code></h4>
 
 ```typescript
-interface PathObject {
-    type: 'posix'|'unc'|'dos'|'devicePath',
-    path: Token[];
-    firstError?: string; //-> first error encounterd in the token array (from left to right)
-}
+function resolve(fromStr = getCWD(), ...toFragments: string[]): ParsedPath | ParsedPathError;
 ```
 
-## Feedback
+<h5 id="fn-resolve-arguments">Arguments:</h5>
+
+- <code>fromStr: <i>string</i></code>: A path according to a <a href="">path type</a>.
+- <code>toFragments: <i>string[]</i></code>: A sequence of paths or path segments.
+
+<h5 id="fn-resolve-return">Return:</h5>
 
-We appreceate any feedback, with new ideas, to enhance this tool suite. File an issue [here](https://github.com/R-js/mangos/issues)
 
-Before contributing, please read our contributing [guidelines](CODE_OF_CONDUCT.md) and [code of conduct](CONTRIBUTING_GUIDELINES.md).
+- <a href="#parsed-path"><code>ParsedPath</code></a>: In case of successfull resolve.
+- <a href="#parsed-path-error"><code>ParsedPathError</code></a>: In case of legal structure but illegal characters in the `from` or `toFragments`.
 
-## [License](LICENSE)
+<h5 id="fn-resolve-throws">throws:</h5>
 
-Copyright (c) 2019-2020 Jacob Bogers `info@mail.jacob-bogers.com`.
+If <code>fromStr</code> is a <a href="#parsed-path-error"><code>ParsedPathError</code></a> an `Error` will be thrown.
+
+<h2>License</h2>
+
+Copyright (c) 2019-2025 Jacob Bogers `jkfbogers@gmail.com`.
 
 Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
 
@@ -285,12 +228,9 @@ http://www.apache.org/licenses/LICENSE-2.0
 
 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
 
-
-[string]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type
-[boolean]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type
+[unc]: https://learn.microsoft.com/en-us/dotnet/standard/io/file-path-formats#unc-paths
 [ddp]: https://docs.microsoft.com/en-us/dotnet/standard/io/file-path-formats#dos-device-paths
 [tdp]: https://docs.microsoft.com/en-us/dotnet/standard/io/file-path-formats#traditional-dos-paths
 [posix]: https://pubs.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap03.html#tag_03_266
-[object]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object
-[mango-mono-repo]: https://github.com/R-js/mangos
+[mangos-mono-repo]: https://github.com/R-js/mangos
 

package/dist/ParsedPath.d.ts

@@ -0,0 +1,9 @@
+import type { FileSystem, ParsedPathDTO } from './parser.js';
+import type { Token } from './Token.js';
+export declare class ParsedPath {
+    readonly path: Token[];
+    readonly type: FileSystem;
+    constructor(parsed: ParsedPathDTO);
+    toString(): string;
+    isRelative(): boolean;
+}

package/dist/ParsedPath.js

@@ -0,0 +1,17 @@
+class ParsedPath {
+  path;
+  type;
+  constructor(parsed) {
+    this.type = parsed.type;
+    this.path = parsed.path;
+  }
+  toString() {
+    return this.path.map((token) => token.value).join("");
+  }
+  isRelative() {
+    return this.path[0].isRoot() === false;
+  }
+}
+export {
+  ParsedPath
+};

package/dist/ParsedPathError.d.ts

@@ -0,0 +1,9 @@
+import type { Token } from 'Token.js';
+import type { FileSystem, ParsedPathDTO } from './parser.js';
+export declare class ParsedPathError {
+    private readonly parsed;
+    readonly path: Token[];
+    readonly type: FileSystem;
+    constructor(parsed: ParsedPathDTO);
+    toString(): string;
+}

package/dist/ParsedPathError.js

@@ -0,0 +1,20 @@
+class ParsedPathError {
+  constructor(parsed) {
+    this.parsed = parsed;
+    this.path = parsed.path;
+    this.type = parsed.type;
+  }
+  path;
+  type;
+  toString() {
+    return this.parsed.path.map((token) => {
+      if (!token.isRoot() && token.error) {
+        return token.error;
+      }
+      return "";
+    }).join("\n");
+  }
+}
+export {
+  ParsedPathError
+};

package/dist/Token.d.ts

@@ -0,0 +1,17 @@
+import type { TokenValueType } from './types/TokenValueType.js';
+export declare class Token {
+    readonly token: TokenValueType;
+    readonly value: string;
+    readonly start: number;
+    readonly end: number;
+    static from(o: {
+        token: TokenValueType;
+        value: string;
+        start: number;
+        end: number;
+        error?: string;
+    }): Token;
+    readonly error?: string;
+    constructor(token: TokenValueType, value: string, start: number, end: number, error?: string);
+    isRoot(): boolean;
+}

package/dist/Token.js

@@ -0,0 +1,22 @@
+import { TokenEnum } from "./constants.js";
+class Token {
+  constructor(token, value, start, end, error) {
+    this.token = token;
+    this.value = value;
+    this.start = start;
+    this.end = end;
+    if (error) {
+      this.error = error;
+    }
+  }
+  static from(o) {
+    return new Token(o.token, o.value, o.start, o.end, o.error);
+  }
+  error;
+  isRoot() {
+    return this.token === TokenEnum.ROOT;
+  }
+}
+export {
+  Token
+};

package/dist/absorbSuccessiveValues.d.ts

@@ -0,0 +1,4 @@
+export default function absorbSuccessiveValues(str: string, fn: (_: string | undefined) => boolean, start: number, end?: number): {
+    end: number;
+    start: number;
+} | undefined;

package/dist/absorbSuccessiveValues.js

@@ -0,0 +1,21 @@
+function absorbSuccessiveValues(str, fn, start, end = str.length - 1) {
+  let i = start;
+  let len = 0;
+  for (; i <= end; i++) {
+    if (fn(str[i])) {
+      len++;
+      continue;
+    }
+    break;
+  }
+  if (len === 0) {
+    return;
+  }
+  return {
+    end: i - 1,
+    start
+  };
+}
+export {
+  absorbSuccessiveValues as default
+};

package/dist/absorbers/ddp.d.ts

@@ -0,0 +1,10 @@
+import { Token } from '../Token.js';
+type RegExporderdMapDDP = {
+    ddpwithUNC: RegExp;
+    ddpwithVolumeUUID: RegExp;
+    ddpwithTDP: RegExp;
+    unc?: RegExp;
+};
+export declare const regExpOrderedMapDDP: RegExporderdMapDDP;
+export declare function ddpAbsorber(str?: string, start?: number, end?: number): Generator<Token, undefined, undefined>;
+export {};

package/dist/absorbers/ddp.js

@@ -0,0 +1,46 @@
+import { TokenEnum } from "../constants.js";
+import { Token } from "../Token.js";
+import { tdpBodyAbsorber } from "./tdp.js";
+const regExpOrderedMapDDP = {
+  //  \\?\UNC\Server\Share\
+  //  \\.\UNC\Server\Share\
+  ddpwithUNC: /^(\/\/|\\\\)(.|\\?)(\/|\\)(unc)(\/|\\)([^/\\]+)(\/|\\)([^/\\]+)(\/|\\)?/i,
+  // example  \\.\Volume{b75e2c83-0000-0000-0000-602f00000000}\
+  // example  \\?\Volume{b75e2c83-0000-0000-0000-602f00000000}\
+  ddpwithVolumeUUID: /^(\/\/|\\\\)(.|\\?)(\/|\\)(Volume{[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}})(\\|\/)?/i,
+  // example  \\?\C:\
+  // example  \\.\C:\
+  ddpwithTDP: /^(\/\/|\\\\)(.|\\?)(\/|\\)([a-z]:)(\/|\\)?/i
+};
+const createRootValueMap = {
+  ddpwithVolumeUUID(match) {
+    return `\\\\?\\${match[4]}`;
+  },
+  ddpwithUNC(match) {
+    return `\\\\?\\UNC\\${match[6]}\\${match[8]}`;
+  },
+  ddpwithTDP(match) {
+    return `\\\\?\\${match[4]}`;
+  }
+};
+function createRootToken(value, offset = 0) {
+  return new Token(TokenEnum.ROOT, value, offset, offset + value.length - 1);
+}
+function* ddpAbsorber(str = "", start = 0, end = str.length - 1) {
+  const pks = Object.keys(regExpOrderedMapDDP);
+  for (const pk of pks) {
+    const match = str.match(regExpOrderedMapDDP[pk]);
+    if (match === null) {
+      continue;
+    }
+    const rootValue = createRootValueMap[pk](match);
+    const record = createRootToken(rootValue, start);
+    yield record;
+    yield* tdpBodyAbsorber(str, record.end + 1, end);
+    break;
+  }
+}
+export {
+  ddpAbsorber,
+  regExpOrderedMapDDP
+};