ventojs 0.6.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Óscar Otero
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,138 @@
+# VENTO
+
+This is a minimal template engine inspired by other great engines like Nunjucks,
+Liquid, Mustache or EJS.
+
+## Why another template engine?
+
+Because I couldn't find the "perfect" template engine for me (probably this one
+neither is). The issues I found in existing template engines:
+
+### Nunjucks
+
+(It's my favorite template engine so far).
+
+- I like:
+  - I can invoke functions like `{{ user.getName() }}`.
+  - Very flexible, with many built-in filters and features
+- I don't like:
+  - It's not well maintained. The last version was released in Jun 2022. And the
+    previous version in 2020.
+  - It's not async-friendly. For example, you have some tags to work with sync
+    values (like `for` and `if`) and others for async values (like `asyncEach`
+    and `ifAysnc`). Some features don't work in async contexts.
+  - To me, it's very uncomfortable to have to type the delimiters `{%` and `%}`
+    all the time (especially the `%` character).
+  - By default, all variables are escaped, so you have to remember to use the
+    `safe` filter everywhere. This is not very convenient for my use case
+    (static site generators), where I can control all the content and the HTML
+    generated.
+  - Some filters are too specific.
+
+### Liquid
+
+- I like:
+  - The support for async evaluation is less hacky than Nunjucks.
+  - The variables are not escaped by default, there's an `escape` filter for
+    that.
+
+- I don't like:
+  - It's not possible to invoke functions in a liquid template. For example
+    `{{ user.getName() }}` fails.
+  - It has the same problem as Nunjucks with the `%` character in the
+    delimiters.
+
+### EJS/Eta
+
+- I like:
+  - It allows running any javascript code in the template.
+- I don't like:
+  - It has the same problem with the `%` character. And I don't like the opening
+    and closing delimiters (`<%` and `%>`).
+  - Because it runs javascript, it's very verbose to do a simple `forEach` or
+    `if`.
+
+### Mustache
+
+- I like:
+  - Very simple, everything is inside `{{` and `}}`.
+  - The closing tag is `{{/tagname}}`, very nice!
+- I don't like:
+  - Perhaps too simple and the syntax can be a bit confusing.
+  - Partials. It's not easy to include them dynamically.
+  - The data context is a bit confusing to me.
+  - Very uncomfortable to work with filters.
+
+### What this new template engine has to offer?
+
+First, let's take a look at this syntax example:
+
+```
+{{ if printName }}
+  {{ await user.getName("full") |> toUpperCase }}
+{{ /if }}
+```
+
+- Everything is between `{{` and `}}` tags. Unlike Nunjucks or Liquid, there's
+  no distinction between tags `{% tag %}` and printing variables `{{ var }}`.
+- The closed tag is done by prepending the `/` character (like Mustache).
+- Async friendly.
+- Like EJS, you can use real JavaScript code everywhere.
+  `await user.getName("full")` is real JS code that will be executed at runtime.
+- Filters are applied using the
+  [pipeline operator](https://github.com/tc39/proposal-pipeline-operator)
+  (`|>`). Note: this is not exactly like the last proposal for JavaScript, it's
+  inspired by
+  ([the previous proposal](https://github.com/valtech-nyc/proposal-fsharp-pipelines)
+  that was rejected but it's way more simple and fits better for filters.
+- Filters can run prototype methods. In this example `users.getName("full")`
+  returns a string, so the `toUpperCase` is a method of the `String` object.
+  It's the same as `users.getName("full").toUpperCase()`.
+
+## Getting started
+
+This is a library for Deno. I'm planning to release an NPM version in the
+future.
+
+First, you need to import the library and create an instance:
+
+```ts
+import vento from "https://deno.land/x/vento@v0.2.0/mod.ts";
+
+const vto = vento({
+  // Resolve the non-relative includes paths
+  includes: "./path/to/includes",
+});
+```
+
+There are different ways to load, compile and run a template. For example, you
+can use `load` to load and compile a template file and return it.
+
+```ts
+// Load and return a template
+const template = vto.load("my-template.vto");
+
+// Now you can use it passing the data
+template({ title: "Hello world" });
+```
+
+Alternatively, you can load and run the template file in a single call:
+
+```ts
+vto.run("my-template.vto", { title: "Hello world" });
+```
+
+If the template code is not a file, you can run it directly:
+
+```ts
+vto.runString("<h1>{{ title }}</h1>", { title: "Hello world" });
+```
+
+## Visual Studio Code Support
+
+[The Vento extension for VS Code](https://marketplace.visualstudio.com/items?itemName=oscarotero.vento-syntax)
+enables syntax highlight and provides some useful snippets.
+
+## API
+
+[Read the docs](https://oscarotero.github.io/vento/)

package/esm/_dnt.shims.d.ts

@@ -0,0 +1,5 @@
+import { Deno } from "@deno/shim-deno";
+export { Deno } from "@deno/shim-deno";
+export declare const dntGlobalThis: Omit<typeof globalThis, "Deno"> & {
+    Deno: typeof Deno;
+};

package/esm/_dnt.shims.js

@@ -0,0 +1,62 @@
+import { Deno } from "@deno/shim-deno";
+export { Deno } from "@deno/shim-deno";
+const dntGlobals = {
+    Deno,
+};
+export const dntGlobalThis = createMergeProxy(globalThis, dntGlobals);
+// deno-lint-ignore ban-types
+function createMergeProxy(baseObj, extObj) {
+    return new Proxy(baseObj, {
+        get(_target, prop, _receiver) {
+            if (prop in extObj) {
+                return extObj[prop];
+            }
+            else {
+                return baseObj[prop];
+            }
+        },
+        set(_target, prop, value) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            baseObj[prop] = value;
+            return true;
+        },
+        deleteProperty(_target, prop) {
+            let success = false;
+            if (prop in extObj) {
+                delete extObj[prop];
+                success = true;
+            }
+            if (prop in baseObj) {
+                delete baseObj[prop];
+                success = true;
+            }
+            return success;
+        },
+        ownKeys(_target) {
+            const baseKeys = Reflect.ownKeys(baseObj);
+            const extKeys = Reflect.ownKeys(extObj);
+            const extKeysSet = new Set(extKeys);
+            return [...baseKeys.filter((k) => !extKeysSet.has(k)), ...extKeys];
+        },
+        defineProperty(_target, prop, desc) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            Reflect.defineProperty(baseObj, prop, desc);
+            return true;
+        },
+        getOwnPropertyDescriptor(_target, prop) {
+            if (prop in extObj) {
+                return Reflect.getOwnPropertyDescriptor(extObj, prop);
+            }
+            else {
+                return Reflect.getOwnPropertyDescriptor(baseObj, prop);
+            }
+        },
+        has(_target, prop) {
+            return prop in extObj || prop in baseObj;
+        },
+    });
+}

package/esm/_dnt.test_polyfills.d.ts

@@ -0,0 +1,11 @@
+declare global {
+    interface Object {
+        /**
+         * Determines whether an object has a property with the specified name.
+         * @param o An object.
+         * @param v A property name.
+         */
+        hasOwn(o: object, v: PropertyKey): boolean;
+    }
+}
+export {};

package/esm/_dnt.test_shims.d.ts

@@ -0,0 +1,5 @@
+import { Deno } from "@deno/shim-deno";
+export { Deno } from "@deno/shim-deno";
+export declare const dntGlobalThis: Omit<typeof globalThis, "Deno"> & {
+    Deno: typeof Deno;
+};

package/esm/deps/deno.land/std@0.178.0/_util/asserts.d.ts

@@ -0,0 +1,10 @@
+/**
+ * All internal non-test code, that is files that do not have `test` or `bench` in the name, must use the assertion functions within `_utils/asserts.ts` and not `testing/asserts.ts`. This is to create a separation of concerns between internal and testing assertions.
+ */
+export declare class DenoStdInternalError extends Error {
+    constructor(message: string);
+}
+/** Make an assertion, if not `true`, then throw. */
+export declare function assert(expr: unknown, msg?: string): asserts expr;
+/** Use this to assert unreachable code. */
+export declare function unreachable(): never;

package/esm/deps/deno.land/std@0.178.0/_util/asserts.js

@@ -0,0 +1,21 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+/**
+ * All internal non-test code, that is files that do not have `test` or `bench` in the name, must use the assertion functions within `_utils/asserts.ts` and not `testing/asserts.ts`. This is to create a separation of concerns between internal and testing assertions.
+ */
+export class DenoStdInternalError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "DenoStdInternalError";
+    }
+}
+/** Make an assertion, if not `true`, then throw. */
+export function assert(expr, msg = "") {
+    if (!expr) {
+        throw new DenoStdInternalError(msg);
+    }
+}
+/** Use this to assert unreachable code. */
+export function unreachable() {
+    throw new DenoStdInternalError("unreachable");
+}

package/esm/deps/deno.land/std@0.178.0/_util/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/esm/deps/deno.land/std@0.178.0/_util/os.js

@@ -0,0 +1,18 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import * as dntShim from "../../../../_dnt.shims.js";
+export const 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";
+})();
+export const isWindows = osType === "windows";
+export const isLinux = osType === "linux";

package/esm/deps/deno.land/std@0.178.0/path/_constants.d.ts

@@ -0,0 +1,39 @@
+export declare const CHAR_UPPERCASE_A = 65;
+export declare const CHAR_LOWERCASE_A = 97;
+export declare const CHAR_UPPERCASE_Z = 90;
+export declare const CHAR_LOWERCASE_Z = 122;
+export declare const CHAR_DOT = 46;
+export declare const CHAR_FORWARD_SLASH = 47;
+export declare const CHAR_BACKWARD_SLASH = 92;
+export declare const CHAR_VERTICAL_LINE = 124;
+export declare const CHAR_COLON = 58;
+export declare const CHAR_QUESTION_MARK = 63;
+export declare const CHAR_UNDERSCORE = 95;
+export declare const CHAR_LINE_FEED = 10;
+export declare const CHAR_CARRIAGE_RETURN = 13;
+export declare const CHAR_TAB = 9;
+export declare const CHAR_FORM_FEED = 12;
+export declare const CHAR_EXCLAMATION_MARK = 33;
+export declare const CHAR_HASH = 35;
+export declare const CHAR_SPACE = 32;
+export declare const CHAR_NO_BREAK_SPACE = 160;
+export declare const CHAR_ZERO_WIDTH_NOBREAK_SPACE = 65279;
+export declare const CHAR_LEFT_SQUARE_BRACKET = 91;
+export declare const CHAR_RIGHT_SQUARE_BRACKET = 93;
+export declare const CHAR_LEFT_ANGLE_BRACKET = 60;
+export declare const CHAR_RIGHT_ANGLE_BRACKET = 62;
+export declare const CHAR_LEFT_CURLY_BRACKET = 123;
+export declare const CHAR_RIGHT_CURLY_BRACKET = 125;
+export declare const CHAR_HYPHEN_MINUS = 45;
+export declare const CHAR_PLUS = 43;
+export declare const CHAR_DOUBLE_QUOTE = 34;
+export declare const CHAR_SINGLE_QUOTE = 39;
+export declare const CHAR_PERCENT = 37;
+export declare const CHAR_SEMICOLON = 59;
+export declare const CHAR_CIRCUMFLEX_ACCENT = 94;
+export declare const CHAR_GRAVE_ACCENT = 96;
+export declare const CHAR_AT = 64;
+export declare const CHAR_AMPERSAND = 38;
+export declare const CHAR_EQUAL = 61;
+export declare const CHAR_0 = 48;
+export declare const CHAR_9 = 57;

package/esm/deps/deno.land/std@0.178.0/path/_constants.js

@@ -0,0 +1,46 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// Copyright the Browserify authors. MIT License.
+// Ported from https://github.com/browserify/path-browserify/
+// This module is browser compatible.
+// Alphabet chars.
+export const CHAR_UPPERCASE_A = 65; /* A */
+export const CHAR_LOWERCASE_A = 97; /* a */
+export const CHAR_UPPERCASE_Z = 90; /* Z */
+export const CHAR_LOWERCASE_Z = 122; /* z */
+// Non-alphabetic chars.
+export const CHAR_DOT = 46; /* . */
+export const CHAR_FORWARD_SLASH = 47; /* / */
+export const CHAR_BACKWARD_SLASH = 92; /* \ */
+export const CHAR_VERTICAL_LINE = 124; /* | */
+export const CHAR_COLON = 58; /* : */
+export const CHAR_QUESTION_MARK = 63; /* ? */
+export const CHAR_UNDERSCORE = 95; /* _ */
+export const CHAR_LINE_FEED = 10; /* \n */
+export const CHAR_CARRIAGE_RETURN = 13; /* \r */
+export const CHAR_TAB = 9; /* \t */
+export const CHAR_FORM_FEED = 12; /* \f */
+export const CHAR_EXCLAMATION_MARK = 33; /* ! */
+export const CHAR_HASH = 35; /* # */
+export const CHAR_SPACE = 32; /*   */
+export const CHAR_NO_BREAK_SPACE = 160; /* \u00A0 */
+export const CHAR_ZERO_WIDTH_NOBREAK_SPACE = 65279; /* \uFEFF */
+export const CHAR_LEFT_SQUARE_BRACKET = 91; /* [ */
+export const CHAR_RIGHT_SQUARE_BRACKET = 93; /* ] */
+export const CHAR_LEFT_ANGLE_BRACKET = 60; /* < */
+export const CHAR_RIGHT_ANGLE_BRACKET = 62; /* > */
+export const CHAR_LEFT_CURLY_BRACKET = 123; /* { */
+export const CHAR_RIGHT_CURLY_BRACKET = 125; /* } */
+export const CHAR_HYPHEN_MINUS = 45; /* - */
+export const CHAR_PLUS = 43; /* + */
+export const CHAR_DOUBLE_QUOTE = 34; /* " */
+export const CHAR_SINGLE_QUOTE = 39; /* ' */
+export const CHAR_PERCENT = 37; /* % */
+export const CHAR_SEMICOLON = 59; /* ; */
+export const CHAR_CIRCUMFLEX_ACCENT = 94; /* ^ */
+export const CHAR_GRAVE_ACCENT = 96; /* ` */
+export const CHAR_AT = 64; /* @ */
+export const CHAR_AMPERSAND = 38; /* & */
+export const CHAR_EQUAL = 61; /* = */
+// Digits
+export const CHAR_0 = 48; /* 0 */
+export const CHAR_9 = 57; /* 9 */

package/esm/deps/deno.land/std@0.178.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/esm/deps/deno.land/std@0.178.0/path/_interface.js

@@ -0,0 +1,3 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+export {};

package/esm/deps/deno.land/std@0.178.0/path/_util.d.ts

@@ -0,0 +1,11 @@
+import type { FormatInputPathObject } from "./_interface.js";
+export declare function assertPath(path: string): void;
+export declare function isPosixPathSeparator(code: number): boolean;
+export declare function isPathSeparator(code: number): boolean;
+export declare function isWindowsDeviceRoot(code: number): boolean;
+export declare function normalizeString(path: string, allowAboveRoot: boolean, separator: string, isPathSeparator: (code: number) => boolean): string;
+export declare function _format(sep: string, pathObject: FormatInputPathObject): string;
+export declare function encodeWhitespace(string: string): string;
+export declare function lastPathSegment(path: string, isSep: (char: number) => boolean, start?: number): string;
+export declare function stripTrailingSeparators(segment: string, isSep: (char: number) => boolean): string;
+export declare function stripSuffix(name: string, suffix: string): string;

package/esm/deps/deno.land/std@0.178.0/path/_util.js

@@ -0,0 +1,161 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// Copyright the Browserify authors. MIT License.
+// Ported from https://github.com/browserify/path-browserify/
+// This module is browser compatible.
+import { CHAR_BACKWARD_SLASH, CHAR_DOT, CHAR_FORWARD_SLASH, CHAR_LOWERCASE_A, CHAR_LOWERCASE_Z, CHAR_UPPERCASE_A, CHAR_UPPERCASE_Z, } from "./_constants.js";
+export function assertPath(path) {
+    if (typeof path !== "string") {
+        throw new TypeError(`Path must be a string. Received ${JSON.stringify(path)}`);
+    }
+}
+export function isPosixPathSeparator(code) {
+    return code === CHAR_FORWARD_SLASH;
+}
+export function isPathSeparator(code) {
+    return isPosixPathSeparator(code) || code === CHAR_BACKWARD_SLASH;
+}
+export function isWindowsDeviceRoot(code) {
+    return ((code >= CHAR_LOWERCASE_A && code <= CHAR_LOWERCASE_Z) ||
+        (code >= CHAR_UPPERCASE_A && code <= CHAR_UPPERCASE_Z));
+}
+// Resolves . and .. elements in a path with directory names
+export function normalizeString(path, allowAboveRoot, separator, isPathSeparator) {
+    let res = "";
+    let lastSegmentLength = 0;
+    let lastSlash = -1;
+    let dots = 0;
+    let code;
+    for (let i = 0, len = path.length; i <= len; ++i) {
+        if (i < len)
+            code = path.charCodeAt(i);
+        else if (isPathSeparator(code))
+            break;
+        else
+            code = CHAR_FORWARD_SLASH;
+        if (isPathSeparator(code)) {
+            if (lastSlash === i - 1 || dots === 1) {
+                // NOOP
+            }
+            else if (lastSlash !== i - 1 && dots === 2) {
+                if (res.length < 2 ||
+                    lastSegmentLength !== 2 ||
+                    res.charCodeAt(res.length - 1) !== CHAR_DOT ||
+                    res.charCodeAt(res.length - 2) !== CHAR_DOT) {
+                    if (res.length > 2) {
+                        const lastSlashIndex = res.lastIndexOf(separator);
+                        if (lastSlashIndex === -1) {
+                            res = "";
+                            lastSegmentLength = 0;
+                        }
+                        else {
+                            res = res.slice(0, lastSlashIndex);
+                            lastSegmentLength = res.length - 1 - res.lastIndexOf(separator);
+                        }
+                        lastSlash = i;
+                        dots = 0;
+                        continue;
+                    }
+                    else if (res.length === 2 || res.length === 1) {
+                        res = "";
+                        lastSegmentLength = 0;
+                        lastSlash = i;
+                        dots = 0;
+                        continue;
+                    }
+                }
+                if (allowAboveRoot) {
+                    if (res.length > 0)
+                        res += `${separator}..`;
+                    else
+                        res = "..";
+                    lastSegmentLength = 2;
+                }
+            }
+            else {
+                if (res.length > 0)
+                    res += separator + path.slice(lastSlash + 1, i);
+                else
+                    res = path.slice(lastSlash + 1, i);
+                lastSegmentLength = i - lastSlash - 1;
+            }
+            lastSlash = i;
+            dots = 0;
+        }
+        else if (code === CHAR_DOT && dots !== -1) {
+            ++dots;
+        }
+        else {
+            dots = -1;
+        }
+    }
+    return res;
+}
+export function _format(sep, pathObject) {
+    const dir = pathObject.dir || pathObject.root;
+    const base = pathObject.base ||
+        (pathObject.name || "") + (pathObject.ext || "");
+    if (!dir)
+        return base;
+    if (base === sep)
+        return dir;
+    if (dir === pathObject.root)
+        return dir + base;
+    return dir + sep + base;
+}
+const WHITESPACE_ENCODINGS = {
+    "\u0009": "%09",
+    "\u000A": "%0A",
+    "\u000B": "%0B",
+    "\u000C": "%0C",
+    "\u000D": "%0D",
+    "\u0020": "%20",
+};
+export function encodeWhitespace(string) {
+    return string.replaceAll(/[\s]/g, (c) => {
+        return WHITESPACE_ENCODINGS[c] ?? c;
+    });
+}
+export function lastPathSegment(path, isSep, start = 0) {
+    let matchedNonSeparator = false;
+    let end = path.length;
+    for (let i = path.length - 1; i >= start; --i) {
+        if (isSep(path.charCodeAt(i))) {
+            if (matchedNonSeparator) {
+                start = i + 1;
+                break;
+            }
+        }
+        else if (!matchedNonSeparator) {
+            matchedNonSeparator = true;
+            end = i + 1;
+        }
+    }
+    return path.slice(start, end);
+}
+export function stripTrailingSeparators(segment, isSep) {
+    if (segment.length <= 1) {
+        return segment;
+    }
+    let end = segment.length;
+    for (let i = segment.length - 1; i > 0; i--) {
+        if (isSep(segment.charCodeAt(i))) {
+            end = i;
+        }
+        else {
+            break;
+        }
+    }
+    return segment.slice(0, end);
+}
+export function stripSuffix(name, suffix) {
+    if (suffix.length >= name.length) {
+        return name;
+    }
+    const lenDiff = name.length - suffix.length;
+    for (let i = suffix.length - 1; i >= 0; --i) {
+        if (name.charCodeAt(lenDiff + i) !== suffix.charCodeAt(i)) {
+            return name;
+        }
+    }
+    return name.slice(0, -suffix.length);
+}

package/esm/deps/deno.land/std@0.178.0/path/common.d.ts

@@ -0,0 +1,13 @@
+/** Determines the common path from a set of paths, using an optional separator,
+ * which defaults to the OS default separator.
+ *
+ * ```ts
+ *       import { common } from "https://deno.land/std@$STD_VERSION/path/mod.ts";
+ *       const p = common([
+ *         "./deno/std/path/mod.ts",
+ *         "./deno/std/fs/mod.ts",
+ *       ]);
+ *       console.log(p); // "./deno/std/"
+ * ```
+ */
+export declare function common(paths: string[], sep?: string): string;

package/esm/deps/deno.land/std@0.178.0/path/common.js

@@ -0,0 +1,36 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { SEP } from "./separator.js";
+/** Determines the common path from a set of paths, using an optional separator,
+ * which defaults to the OS default separator.
+ *
+ * ```ts
+ *       import { common } from "https://deno.land/std@$STD_VERSION/path/mod.ts";
+ *       const p = common([
+ *         "./deno/std/path/mod.ts",
+ *         "./deno/std/fs/mod.ts",
+ *       ]);
+ *       console.log(p); // "./deno/std/"
+ * ```
+ */
+export function common(paths, sep = SEP) {
+    const [first = "", ...remaining] = paths;
+    if (first === "" || remaining.length === 0) {
+        return first.substring(0, first.lastIndexOf(sep) + 1);
+    }
+    const parts = first.split(sep);
+    let endOfPrefix = parts.length;
+    for (const path of remaining) {
+        const compare = path.split(sep);
+        for (let i = 0; i < endOfPrefix; i++) {
+            if (compare[i] !== parts[i]) {
+                endOfPrefix = i;
+            }
+        }
+        if (endOfPrefix === 0) {
+            return "";
+        }
+    }
+    const prefix = parts.slice(0, endOfPrefix).join(sep);
+    return prefix.endsWith(sep) ? prefix : `${prefix}${sep}`;
+}