fontconv 0.0.1

package/script/deps/deno.land/std@0.221.0/path/windows/glob_to_regexp.js

@@ -0,0 +1,73 @@
+"use strict";
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globToRegExp = void 0;
+const glob_to_reg_exp_js_1 = require("../_common/glob_to_reg_exp.js");
+const constants = {
+    sep: "(?:\\\\|/)+",
+    sepMaybe: "(?:\\\\|/)*",
+    seps: ["\\", "/"],
+    globstar: "(?:[^\\\\/]*(?:\\\\|/|$)+)*",
+    wildcard: "[^\\\\/]*",
+    escapePrefix: "`",
+};
+/** Convert a glob string to a regular expression.
+ *
+ * Tries to match bash glob expansion as closely as possible.
+ *
+ * Basic glob syntax:
+ * - `*` - Matches everything without leaving the path segment.
+ * - `?` - Matches any single character.
+ * - `{foo,bar}` - Matches `foo` or `bar`.
+ * - `[abcd]` - Matches `a`, `b`, `c` or `d`.
+ * - `[a-d]` - Matches `a`, `b`, `c` or `d`.
+ * - `[!abcd]` - Matches any single character besides `a`, `b`, `c` or `d`.
+ * - `[[:<class>:]]` - Matches any character belonging to `<class>`.
+ *     - `[[:alnum:]]` - Matches any digit or letter.
+ *     - `[[:digit:]abc]` - Matches any digit, `a`, `b` or `c`.
+ *     - See https://facelessuser.github.io/wcmatch/glob/#posix-character-classes
+ *       for a complete list of supported character classes.
+ * - `\` - Escapes the next character for an `os` other than `"windows"`.
+ * - \` - Escapes the next character for `os` set to `"windows"`.
+ * - `/` - Path separator.
+ * - `\` - Additional path separator only for `os` set to `"windows"`.
+ *
+ * Extended syntax:
+ * - Requires `{ extended: true }`.
+ * - `?(foo|bar)` - Matches 0 or 1 instance of `{foo,bar}`.
+ * - `@(foo|bar)` - Matches 1 instance of `{foo,bar}`. They behave the same.
+ * - `*(foo|bar)` - Matches _n_ instances of `{foo,bar}`.
+ * - `+(foo|bar)` - Matches _n > 0_ instances of `{foo,bar}`.
+ * - `!(foo|bar)` - Matches anything other than `{foo,bar}`.
+ * - See https://www.linuxjournal.com/content/bash-extended-globbing.
+ *
+ * Globstar syntax:
+ * - Requires `{ globstar: true }`.
+ * - `**` - Matches any number of any path segments.
+ *     - Must comprise its entire path segment in the provided glob.
+ * - See https://www.linuxjournal.com/content/globstar-new-bash-globbing-option.
+ *
+ * Note the following properties:
+ * - The generated `RegExp` is anchored at both start and end.
+ * - Repeating and trailing separators are tolerated. Trailing separators in the
+ *   provided glob have no meaning and are discarded.
+ * - Absolute globs will only match absolute paths, etc.
+ * - Empty globs will match nothing.
+ * - Any special glob syntax must be contained to one path segment. For example,
+ *   `?(foo|bar/baz)` is invalid. The separator will take precedence and the
+ *   first segment ends with an unclosed group.
+ * - If a path segment ends with unclosed groups or a dangling escape prefix, a
+ *   parse error has occurred. Every character for that segment is taken
+ *   literally in this event.
+ *
+ * Limitations:
+ * - A negative group like `!(foo|bar)` will wrongly be converted to a negative
+ *   look-ahead followed by a wildcard. This means that `!(foo).js` will wrongly
+ *   fail to match `foobar.js`, even though `foobar` is not `foo`. Effectively,
+ *   `!(foo|bar)` is treated like `!(@(foo|bar)*)`. This will work correctly if
+ *   the group occurs not nested at the end of the segment. */
+function globToRegExp(glob, options = {}) {
+    return (0, glob_to_reg_exp_js_1._globToRegExp)(constants, glob, options);
+}
+exports.globToRegExp = globToRegExp;

package/script/deps/deno.land/std@0.221.0/path/windows/is_absolute.d.ts

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

package/script/deps/deno.land/std@0.221.0/path/windows/is_absolute.js

@@ -0,0 +1,31 @@
+"use strict";
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAbsolute = void 0;
+const constants_js_1 = require("../_common/constants.js");
+const assert_path_js_1 = require("../_common/assert_path.js");
+const _util_js_1 = require("./_util.js");
+/**
+ * Verifies whether provided path is absolute
+ * @param path to be verified as absolute
+ */
+function isAbsolute(path) {
+    (0, assert_path_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.isAbsolute = isAbsolute;

package/script/deps/deno.land/std@0.221.0/path/windows/is_glob.d.ts

@@ -0,0 +1 @@
+export { isGlob } from "../is_glob.js";

package/script/deps/deno.land/std@0.221.0/path/windows/is_glob.js

@@ -0,0 +1,7 @@
+"use strict";
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isGlob = void 0;
+var is_glob_js_1 = require("../is_glob.js");
+Object.defineProperty(exports, "isGlob", { enumerable: true, get: function () { return is_glob_js_1.isGlob; } });

package/script/deps/deno.land/std@0.221.0/path/windows/join.d.ts

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

package/script/deps/deno.land/std@0.221.0/path/windows/join.js

@@ -0,0 +1,76 @@
+"use strict";
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.join = void 0;
+const assert_js_1 = require("../../assert/assert.js");
+const assert_path_js_1 = require("../_common/assert_path.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 join(...paths) {
+    if (paths.length === 0)
+        return ".";
+    let joined;
+    let firstPart = null;
+    for (let i = 0; i < paths.length; ++i) {
+        const path = paths[i];
+        (0, assert_path_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.normalize)(joined);
+}
+exports.join = join;

package/script/deps/deno.land/std@0.221.0/path/windows/join_globs.d.ts

@@ -0,0 +1,4 @@
+import type { GlobOptions } from "../_common/glob_to_reg_exp.js";
+export type { GlobOptions };
+/** Like join(), but doesn't collapse "**\/.." when `globstar` is true. */
+export declare function joinGlobs(globs: string[], { extended, globstar }?: GlobOptions): string;

package/script/deps/deno.land/std@0.221.0/path/windows/join_globs.js

@@ -0,0 +1,30 @@
+"use strict";
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.joinGlobs = void 0;
+const join_js_1 = require("./join.js");
+const constants_js_1 = require("./constants.js");
+const normalize_glob_js_1 = require("./normalize_glob.js");
+/** Like join(), but doesn't collapse "**\/.." when `globstar` is true. */
+function joinGlobs(globs, { extended = true, globstar = false } = {}) {
+    if (!globstar || globs.length === 0) {
+        return (0, join_js_1.join)(...globs);
+    }
+    if (globs.length === 0)
+        return ".";
+    let joined;
+    for (const glob of globs) {
+        const path = glob;
+        if (path.length > 0) {
+            if (!joined)
+                joined = path;
+            else
+                joined += `${constants_js_1.SEPARATOR}${path}`;
+        }
+    }
+    if (!joined)
+        return ".";
+    return (0, normalize_glob_js_1.normalizeGlob)(joined, { extended, globstar });
+}
+exports.joinGlobs = joinGlobs;

package/script/deps/deno.land/std@0.221.0/path/windows/mod.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Utilities for working with OS-specific file paths.
+ *
+ * Codes in the examples uses POSIX path but it automatically use Windows path
+ * on Windows. Use methods under `posix` or `win32` object instead to handle non
+ * platform specific path like:
+ * ```ts
+ * import { posix, win32 } from "https://deno.land/std@$STD_VERSION/path/mod.ts";
+ * const p1 = posix.fromFileUrl("file:///home/foo");
+ * const p2 = win32.fromFileUrl("file:///home/foo");
+ * console.log(p1); // "/home/foo"
+ * console.log(p2); // "\\home\\foo"
+ * ```
+ *
+ * This module is browser compatible.
+ *
+ * @module
+ */
+export * from "./basename.js";
+export * from "./constants.js";
+export * from "./dirname.js";
+export * from "./extname.js";
+export * from "./format.js";
+export * from "./from_file_url.js";
+export * from "./is_absolute.js";
+export * from "./join.js";
+export * from "./normalize.js";
+export * from "./parse.js";
+export * from "./relative.js";
+export * from "./resolve.js";
+export * from "./to_file_url.js";
+export * from "./to_namespaced_path.js";
+export * from "./common.js";
+export * from "../_interface.js";
+export * from "./glob_to_regexp.js";
+export * from "./is_glob.js";
+export * from "./join_globs.js";
+export * from "./normalize_glob.js";

package/script/deps/deno.land/std@0.221.0/path/windows/mod.js

@@ -0,0 +1,58 @@
+"use strict";
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// Copyright the Browserify authors. MIT License.
+// Ported mostly from https://github.com/browserify/path-browserify/
+// This module is browser compatible.
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Utilities for working with OS-specific file paths.
+ *
+ * Codes in the examples uses POSIX path but it automatically use Windows path
+ * on Windows. Use methods under `posix` or `win32` object instead to handle non
+ * platform specific path like:
+ * ```ts
+ * import { posix, win32 } from "https://deno.land/std@$STD_VERSION/path/mod.ts";
+ * const p1 = posix.fromFileUrl("file:///home/foo");
+ * const p2 = win32.fromFileUrl("file:///home/foo");
+ * console.log(p1); // "/home/foo"
+ * console.log(p2); // "\\home\\foo"
+ * ```
+ *
+ * This module is browser compatible.
+ *
+ * @module
+ */
+__exportStar(require("./basename.js"), exports);
+__exportStar(require("./constants.js"), exports);
+__exportStar(require("./dirname.js"), exports);
+__exportStar(require("./extname.js"), exports);
+__exportStar(require("./format.js"), exports);
+__exportStar(require("./from_file_url.js"), exports);
+__exportStar(require("./is_absolute.js"), exports);
+__exportStar(require("./join.js"), exports);
+__exportStar(require("./normalize.js"), exports);
+__exportStar(require("./parse.js"), exports);
+__exportStar(require("./relative.js"), exports);
+__exportStar(require("./resolve.js"), exports);
+__exportStar(require("./to_file_url.js"), exports);
+__exportStar(require("./to_namespaced_path.js"), exports);
+__exportStar(require("./common.js"), exports);
+__exportStar(require("../_interface.js"), exports);
+__exportStar(require("./glob_to_regexp.js"), exports);
+__exportStar(require("./is_glob.js"), exports);
+__exportStar(require("./join_globs.js"), exports);
+__exportStar(require("./normalize_glob.js"), exports);

package/script/deps/deno.land/std@0.221.0/path/windows/normalize.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 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 normalize(path: string): string;

package/script/deps/deno.land/std@0.221.0/path/windows/normalize.js

@@ -0,0 +1,134 @@
+"use strict";
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalize = void 0;
+const normalize_js_1 = require("../_common/normalize.js");
+const constants_js_1 = require("../_common/constants.js");
+const normalize_string_js_1 = require("../_common/normalize_string.js");
+const _util_js_1 = require("./_util.js");
+/**
+ * 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 normalize(path) {
+    (0, normalize_js_1.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, normalize_string_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.normalize = normalize;

package/script/deps/deno.land/std@0.221.0/path/windows/normalize_glob.d.ts

@@ -0,0 +1,4 @@
+import type { GlobOptions } from "../_common/glob_to_reg_exp.js";
+export type { GlobOptions };
+/** Like normalize(), but doesn't collapse "**\/.." when `globstar` is true. */
+export declare function normalizeGlob(glob: string, { globstar }?: GlobOptions): string;

package/script/deps/deno.land/std@0.221.0/path/windows/normalize_glob.js

@@ -0,0 +1,20 @@
+"use strict";
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeGlob = void 0;
+const normalize_js_1 = require("./normalize.js");
+const constants_js_1 = require("./constants.js");
+/** Like normalize(), but doesn't collapse "**\/.." when `globstar` is true. */
+function normalizeGlob(glob, { globstar = false } = {}) {
+    if (glob.match(/\0/g)) {
+        throw new Error(`Glob contains invalid characters: "${glob}"`);
+    }
+    if (!globstar) {
+        return (0, normalize_js_1.normalize)(glob);
+    }
+    const s = constants_js_1.SEPARATOR_PATTERN.source;
+    const badParentPattern = new RegExp(`(?<=(${s}|^)\\*\\*${s})\\.\\.(?=${s}|$)`, "g");
+    return (0, normalize_js_1.normalize)(glob.replace(badParentPattern, "\0")).replace(/\0/g, "..");
+}
+exports.normalizeGlob = normalizeGlob;

package/script/deps/deno.land/std@0.221.0/path/windows/parse.d.ts

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