ventojs 0.8.0 → 0.9.0

package/script/deps/deno.land/std@0.201.0/path/_from_file_url.js

@@ -0,0 +1,51 @@
+"use strict";
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.windowsFromFileUrl = exports.posixFromFileUrl = void 0;
+function assertArg(url) {
+    url = url instanceof URL ? url : new URL(url);
+    if (url.protocol !== "file:") {
+        throw new TypeError("Must be a file URL.");
+    }
+    return url;
+}
+/**
+ * Converts a file URL to a path string.
+ *
+ * ```ts
+ * import { fromFileUrl } from "https://deno.land/std@$STD_VERSION/path/posix.ts";
+ *
+ * fromFileUrl("file:///home/foo"); // "/home/foo"
+ * ```
+ * @param url of a file URL
+ */
+function posixFromFileUrl(url) {
+    url = assertArg(url);
+    return decodeURIComponent(url.pathname.replace(/%(?![0-9A-Fa-f]{2})/g, "%25"));
+}
+exports.posixFromFileUrl = posixFromFileUrl;
+/**
+ * Converts a file URL to a path string.
+ *
+ * ```ts
+ * import { fromFileUrl } from "https://deno.land/std@$STD_VERSION/path/win32.ts";
+ *
+ * fromFileUrl("file:///home/foo"); // "\\home\\foo"
+ * fromFileUrl("file:///C:/Users/foo"); // "C:\\Users\\foo"
+ * fromFileUrl("file://localhost/home/foo"); // "\\\\localhost\\home\\foo"
+ * ```
+ * @param url of a file URL
+ */
+function windowsFromFileUrl(url) {
+    url = assertArg(url);
+    let path = decodeURIComponent(url.pathname.replace(/\//g, "\\").replace(/%(?![0-9A-Fa-f]{2})/g, "%25")).replace(/^\\*([A-Za-z]:)(\\|$)/, "$1\\");
+    if (url.hostname !== "") {
+        // Note: The `URL` implementation guarantees that the drive letter and
+        // hostname are mutually exclusive. Otherwise it would not have been valid
+        // to append the hostname and path like this.
+        path = `\\\\${url.hostname}${path}`;
+    }
+    return path;
+}
+exports.windowsFromFileUrl = windowsFromFileUrl;

package/script/deps/deno.land/std@0.201.0/path/_interface.d.ts

@@ -0,0 +1,26 @@
+/**
+ * A parsed path object generated by path.parse() or consumed by path.format().
+ */
+export interface ParsedPath {
+    /**
+     * The root of the path such as '/' or 'c:\'
+     */
+    root: string;
+    /**
+     * The full directory path such as '/home/user/dir' or 'c:\path\dir'
+     */
+    dir: string;
+    /**
+     * The file name including extension (if any) such as 'index.html'
+     */
+    base: string;
+    /**
+     * The file extension (if any) such as '.html'
+     */
+    ext: string;
+    /**
+     * The file name without extension (if any) such as 'index'
+     */
+    name: string;
+}
+export type FormatInputPathObject = Partial<ParsedPath>;

package/script/deps/deno.land/std@0.201.0/path/_interface.js

@@ -0,0 +1,4 @@
+"use strict";
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });

package/script/deps/deno.land/std@0.201.0/path/_is_absolute.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Verifies whether provided path is absolute
+ * @param path to be verified as absolute
+ */
+export declare function windowsIsAbsolute(path: string): boolean;
+/**
+ * Verifies whether provided path is absolute
+ * @param path to be verified as absolute
+ */
+export declare function posixIsAbsolute(path: string): boolean;

package/script/deps/deno.land/std@0.201.0/path/_is_absolute.js

@@ -0,0 +1,39 @@
+"use strict";
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.posixIsAbsolute = exports.windowsIsAbsolute = void 0;
+const _constants_js_1 = require("./_constants.js");
+const _util_js_1 = require("./_util.js");
+/**
+ * Verifies whether provided path is absolute
+ * @param path to be verified as absolute
+ */
+function windowsIsAbsolute(path) {
+    (0, _util_js_1.assertPath)(path);
+    const len = path.length;
+    if (len === 0)
+        return false;
+    const code = path.charCodeAt(0);
+    if ((0, _util_js_1.isPathSeparator)(code)) {
+        return true;
+    }
+    else if ((0, _util_js_1.isWindowsDeviceRoot)(code)) {
+        // Possible device root
+        if (len > 2 && path.charCodeAt(1) === _constants_js_1.CHAR_COLON) {
+            if ((0, _util_js_1.isPathSeparator)(path.charCodeAt(2)))
+                return true;
+        }
+    }
+    return false;
+}
+exports.windowsIsAbsolute = windowsIsAbsolute;
+/**
+ * Verifies whether provided path is absolute
+ * @param path to be verified as absolute
+ */
+function posixIsAbsolute(path) {
+    (0, _util_js_1.assertPath)(path);
+    return path.length > 0 && (0, _util_js_1.isPosixPathSeparator)(path.charCodeAt(0));
+}
+exports.posixIsAbsolute = posixIsAbsolute;

package/script/deps/deno.land/std@0.201.0/path/_join.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Join all given a sequence of `paths`,then normalizes the resulting path.
+ * @param paths to be joined and normalized
+ */
+export declare function posixJoin(...paths: string[]): string;
+/**
+ * Join all given a sequence of `paths`,then normalizes the resulting path.
+ * @param paths to be joined and normalized
+ */
+export declare function windowsJoin(...paths: string[]): string;

package/script/deps/deno.land/std@0.201.0/path/_join.js

@@ -0,0 +1,98 @@
+"use strict";
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.windowsJoin = exports.posixJoin = void 0;
+const assert_js_1 = require("../assert/assert.js");
+const _util_js_1 = require("./_util.js");
+const _normalize_js_1 = require("./_normalize.js");
+/**
+ * Join all given a sequence of `paths`,then normalizes the resulting path.
+ * @param paths to be joined and normalized
+ */
+function posixJoin(...paths) {
+    if (paths.length === 0)
+        return ".";
+    let joined;
+    for (let i = 0, len = paths.length; i < len; ++i) {
+        const path = paths[i];
+        (0, _util_js_1.assertPath)(path);
+        if (path.length > 0) {
+            if (!joined)
+                joined = path;
+            else
+                joined += `/${path}`;
+        }
+    }
+    if (!joined)
+        return ".";
+    return (0, _normalize_js_1.posixNormalize)(joined);
+}
+exports.posixJoin = posixJoin;
+/**
+ * Join all given a sequence of `paths`,then normalizes the resulting path.
+ * @param paths to be joined and normalized
+ */
+function windowsJoin(...paths) {
+    if (paths.length === 0)
+        return ".";
+    let joined;
+    let firstPart = null;
+    for (let i = 0; i < paths.length; ++i) {
+        const path = paths[i];
+        (0, _util_js_1.assertPath)(path);
+        if (path.length > 0) {
+            if (joined === undefined)
+                joined = firstPart = path;
+            else
+                joined += `\\${path}`;
+        }
+    }
+    if (joined === undefined)
+        return ".";
+    // Make sure that the joined path doesn't start with two slashes, because
+    // normalize() will mistake it for an UNC path then.
+    //
+    // This step is skipped when it is very clear that the user actually
+    // intended to point at an UNC path. This is assumed when the first
+    // non-empty string arguments starts with exactly two slashes followed by
+    // at least one more non-slash character.
+    //
+    // Note that for normalize() to treat a path as an UNC path it needs to
+    // have at least 2 components, so we don't filter for that here.
+    // This means that the user can use join to construct UNC paths from
+    // a server name and a share name; for example:
+    //   path.join('//server', 'share') -> '\\\\server\\share\\')
+    let needsReplace = true;
+    let slashCount = 0;
+    (0, assert_js_1.assert)(firstPart !== null);
+    if ((0, _util_js_1.isPathSeparator)(firstPart.charCodeAt(0))) {
+        ++slashCount;
+        const firstLen = firstPart.length;
+        if (firstLen > 1) {
+            if ((0, _util_js_1.isPathSeparator)(firstPart.charCodeAt(1))) {
+                ++slashCount;
+                if (firstLen > 2) {
+                    if ((0, _util_js_1.isPathSeparator)(firstPart.charCodeAt(2)))
+                        ++slashCount;
+                    else {
+                        // We matched a UNC path in the first part
+                        needsReplace = false;
+                    }
+                }
+            }
+        }
+    }
+    if (needsReplace) {
+        // Find any more consecutive slashes we need to replace
+        for (; slashCount < joined.length; ++slashCount) {
+            if (!(0, _util_js_1.isPathSeparator)(joined.charCodeAt(slashCount)))
+                break;
+        }
+        // Replace the slashes if needed
+        if (slashCount >= 2)
+            joined = `\\${joined.slice(slashCount)}`;
+    }
+    return (0, _normalize_js_1.windowsNormalize)(joined);
+}
+exports.windowsJoin = windowsJoin;

package/script/deps/deno.land/std@0.201.0/path/_normalize.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Normalize the `path`, resolving `'..'` and `'.'` segments.
+ * Note that resolving these segments does not necessarily mean that all will be eliminated.
+ * A `'..'` at the top-level will be preserved, and an empty path is canonically `'.'`.
+ * @param path to be normalized
+ */
+export declare function posixNormalize(path: string): string;
+/**
+ * Normalize the `path`, resolving `'..'` and `'.'` segments.
+ * Note that resolving these segments does not necessarily mean that all will be eliminated.
+ * A `'..'` at the top-level will be preserved, and an empty path is canonically `'.'`.
+ * @param path to be normalized
+ */
+export declare function windowsNormalize(path: string): string;

package/script/deps/deno.land/std@0.201.0/path/_normalize.js

@@ -0,0 +1,158 @@
+"use strict";
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.windowsNormalize = exports.posixNormalize = void 0;
+const _constants_js_1 = require("./_constants.js");
+const _util_js_1 = require("./_util.js");
+function assertArg(path) {
+    (0, _util_js_1.assertPath)(path);
+    if (path.length === 0)
+        return ".";
+}
+/**
+ * Normalize the `path`, resolving `'..'` and `'.'` segments.
+ * Note that resolving these segments does not necessarily mean that all will be eliminated.
+ * A `'..'` at the top-level will be preserved, and an empty path is canonically `'.'`.
+ * @param path to be normalized
+ */
+function posixNormalize(path) {
+    assertArg(path);
+    const isAbsolute = (0, _util_js_1.isPosixPathSeparator)(path.charCodeAt(0));
+    const trailingSeparator = (0, _util_js_1.isPosixPathSeparator)(path.charCodeAt(path.length - 1));
+    // Normalize the path
+    path = (0, _util_js_1.normalizeString)(path, !isAbsolute, "/", _util_js_1.isPosixPathSeparator);
+    if (path.length === 0 && !isAbsolute)
+        path = ".";
+    if (path.length > 0 && trailingSeparator)
+        path += "/";
+    if (isAbsolute)
+        return `/${path}`;
+    return path;
+}
+exports.posixNormalize = posixNormalize;
+/**
+ * Normalize the `path`, resolving `'..'` and `'.'` segments.
+ * Note that resolving these segments does not necessarily mean that all will be eliminated.
+ * A `'..'` at the top-level will be preserved, and an empty path is canonically `'.'`.
+ * @param path to be normalized
+ */
+function windowsNormalize(path) {
+    assertArg(path);
+    const len = path.length;
+    let rootEnd = 0;
+    let device;
+    let isAbsolute = false;
+    const code = path.charCodeAt(0);
+    // Try to match a root
+    if (len > 1) {
+        if ((0, _util_js_1.isPathSeparator)(code)) {
+            // Possible UNC root
+            // If we started with a separator, we know we at least have an absolute
+            // path of some kind (UNC or otherwise)
+            isAbsolute = true;
+            if ((0, _util_js_1.isPathSeparator)(path.charCodeAt(1))) {
+                // Matched double path separator at beginning
+                let j = 2;
+                let last = j;
+                // Match 1 or more non-path separators
+                for (; j < len; ++j) {
+                    if ((0, _util_js_1.isPathSeparator)(path.charCodeAt(j)))
+                        break;
+                }
+                if (j < len && j !== last) {
+                    const firstPart = path.slice(last, j);
+                    // Matched!
+                    last = j;
+                    // Match 1 or more path separators
+                    for (; j < len; ++j) {
+                        if (!(0, _util_js_1.isPathSeparator)(path.charCodeAt(j)))
+                            break;
+                    }
+                    if (j < len && j !== last) {
+                        // Matched!
+                        last = j;
+                        // Match 1 or more non-path separators
+                        for (; j < len; ++j) {
+                            if ((0, _util_js_1.isPathSeparator)(path.charCodeAt(j)))
+                                break;
+                        }
+                        if (j === len) {
+                            // We matched a UNC root only
+                            // Return the normalized version of the UNC root since there
+                            // is nothing left to process
+                            return `\\\\${firstPart}\\${path.slice(last)}\\`;
+                        }
+                        else if (j !== last) {
+                            // We matched a UNC root with leftovers
+                            device = `\\\\${firstPart}\\${path.slice(last, j)}`;
+                            rootEnd = j;
+                        }
+                    }
+                }
+            }
+            else {
+                rootEnd = 1;
+            }
+        }
+        else if ((0, _util_js_1.isWindowsDeviceRoot)(code)) {
+            // Possible device root
+            if (path.charCodeAt(1) === _constants_js_1.CHAR_COLON) {
+                device = path.slice(0, 2);
+                rootEnd = 2;
+                if (len > 2) {
+                    if ((0, _util_js_1.isPathSeparator)(path.charCodeAt(2))) {
+                        // Treat separator following drive name as an absolute path
+                        // indicator
+                        isAbsolute = true;
+                        rootEnd = 3;
+                    }
+                }
+            }
+        }
+    }
+    else if ((0, _util_js_1.isPathSeparator)(code)) {
+        // `path` contains just a path separator, exit early to avoid unnecessary
+        // work
+        return "\\";
+    }
+    let tail;
+    if (rootEnd < len) {
+        tail = (0, _util_js_1.normalizeString)(path.slice(rootEnd), !isAbsolute, "\\", _util_js_1.isPathSeparator);
+    }
+    else {
+        tail = "";
+    }
+    if (tail.length === 0 && !isAbsolute)
+        tail = ".";
+    if (tail.length > 0 && (0, _util_js_1.isPathSeparator)(path.charCodeAt(len - 1))) {
+        tail += "\\";
+    }
+    if (device === undefined) {
+        if (isAbsolute) {
+            if (tail.length > 0)
+                return `\\${tail}`;
+            else
+                return "\\";
+        }
+        else if (tail.length > 0) {
+            return tail;
+        }
+        else {
+            return "";
+        }
+    }
+    else if (isAbsolute) {
+        if (tail.length > 0)
+            return `${device}\\${tail}`;
+        else
+            return `${device}\\`;
+    }
+    else if (tail.length > 0) {
+        return device + tail;
+    }
+    else {
+        return device;
+    }
+}
+exports.windowsNormalize = windowsNormalize;

package/script/deps/deno.land/std@0.201.0/path/_os.d.ts

@@ -0,0 +1,4 @@
+export type OSType = "windows" | "linux" | "darwin" | "freebsd";
+export declare const osType: OSType;
+export declare const isWindows: boolean;
+export declare const isLinux: boolean;

package/script/deps/deno.land/std@0.201.0/path/_os.js

@@ -0,0 +1,44 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLinux = exports.isWindows = exports.osType = void 0;
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+const dntShim = __importStar(require("../../../../_dnt.shims.js"));
+exports.osType = (() => {
+    // deno-lint-ignore no-explicit-any
+    const { Deno } = dntShim.dntGlobalThis;
+    if (typeof Deno?.build?.os === "string") {
+        return Deno.build.os;
+    }
+    // deno-lint-ignore no-explicit-any
+    const { navigator } = dntShim.dntGlobalThis;
+    if (navigator?.appVersion?.includes?.("Win")) {
+        return "windows";
+    }
+    return "linux";
+})();
+exports.isWindows = exports.osType === "windows";
+exports.isLinux = exports.osType === "linux";

package/script/deps/deno.land/std@0.201.0/path/_parse.d.ts

@@ -0,0 +1,11 @@
+import { ParsedPath } from "./_interface.js";
+/**
+ * Return a `ParsedPath` object of the `path`.
+ * @param path to process
+ */
+export declare function posixParse(path: string): ParsedPath;
+/**
+ * Return a `ParsedPath` object of the `path`.
+ * @param path to process
+ */
+export declare function windowsParse(path: string): ParsedPath;