@lowlighter/toolbox 1.0.1

package/README.md

@@ -0,0 +1,14 @@
+# 🧰 Toolbox
+
+[![JSR](https://jsr.io/badges/@libs/toolbox)](https://jsr.io/@libs/toolbox) [![JSR Score](https://jsr.io/badges/@libs/toolbox/score)](https://jsr.io/@libs/toolbox)
+
+A set of miscellaneous utilities.
+
+- [`📚 Documentation`](https://jsr.io/@libs/toolbox/doc)
+
+## 📜 License
+
+```plaintext
+Copyright (c) Simon Lecoq <@lowlighter>. (MIT License)
+https://github.com/lowlighter/libs/blob/main/LICENSE
+```

package/clone.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Clones a value deeply.
+ *
+ * If `structuredCloneable` is set, the clone will be compatible with `structuredClone` algorithm, meaning that:
+ * - Proxy are unproxyed to plain objects
+ * - Incompatible types are ignored
+ */ export declare function clone<T>(value: T, options?: {
+  structuredCloneable?: boolean;
+}): T;

package/clone.js

@@ -0,0 +1,37 @@
+/**
+ * Clones a value deeply.
+ *
+ * If `structuredCloneable` is set, the clone will be compatible with `structuredClone` algorithm, meaning that:
+ * - Proxy are unproxyed to plain objects
+ * - Incompatible types are ignored
+ */ export function clone(value, options) {
+  return _clone(value, options, new WeakMap());
+}
+/** {@linkcode clone()} implementation. */ function _clone(value, options, seen) {
+  if (Array.isArray(value)) {
+    if (seen.has(value)) return seen.get(value);
+    const cloned = [];
+    seen.set(value, cloned);
+    for (const item of value)cloned.push(_clone(item, options, seen));
+    return cloned;
+  }
+  if ([
+    Date,
+    Error,
+    Map,
+    Set,
+    RegExp
+  ].some((type)=>value instanceof type)) return structuredClone(value);
+  if (typeof value === "object" && value !== null) {
+    if (seen.has(value)) return seen.get(value);
+    const cloned = {};
+    seen.set(value, cloned);
+    for (const [k, v] of Object.entries(value)){
+      if (options?.structuredCloneable && (typeof v === "symbol" || typeof v === "function")) continue;
+      cloned[k] = _clone(v, options, seen);
+    }
+    return cloned;
+  }
+  return value;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/deno.lock

@@ -0,0 +1,53 @@
+{
+  "version": "5",
+  "specifiers": {
+    "jsr:@std/cli@^1.0.28": "1.0.31",
+    "jsr:@std/fs@^1.0.23": "1.0.24",
+    "jsr:@std/internal@^1.0.14": "1.0.14",
+    "jsr:@std/path@^1.1.4": "1.1.6",
+    "jsr:@std/path@^1.1.5": "1.1.6"
+  },
+  "jsr": {
+    "@std/cli@1.0.31": {
+      "integrity": "190bb61f809378267c06be3bcd689fcc540f0cfaa5892171144cae787d02e2fd",
+      "dependencies": [
+        "jsr:@std/internal"
+      ]
+    },
+    "@std/fs@1.0.24": {
+      "integrity": "f3061b45b81673a2bece689da041df32d174be064c89eb6397fb5718d3fb7877",
+      "dependencies": [
+        "jsr:@std/internal",
+        "jsr:@std/path@^1.1.5"
+      ]
+    },
+    "@std/internal@1.0.14": {
+      "integrity": "291516b3d4c35024d6ffbc0a9df5bf4c64116e05b50012cf846710152d2ffdf7"
+    },
+    "@std/path@1.1.6": {
+      "integrity": "c68485c2a4dfbb5ae3cc74fae4e8c4e5d874cf8a8ed12927917235c758b46cbe",
+      "dependencies": [
+        "jsr:@std/internal"
+      ]
+    }
+  },
+  "workspace": {
+    "dependencies": [
+      "jsr:@std/cli@^1.0.28",
+      "jsr:@std/encoding@^1.0.10",
+      "jsr:@std/fs@^1.0.23",
+      "jsr:@std/path@^1.1.4",
+      "jsr:@std/streams@^1.0.17",
+      "jsr:@std/tar@0.1.10"
+    ],
+    "packageJson": {
+      "dependencies": [
+        "npm:@jsr/std__cli@^1.0.28",
+        "npm:@jsr/std__fs@^1.0.23",
+        "npm:@jsr/std__path@^1.1.4",
+        "npm:@jsr/std__streams@^1.0.17",
+        "npm:@jsr/std__tar@~0.1.10"
+      ]
+    }
+  }
+}

package/env.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Reads an environment variable.
+ *
+ * An empty string is returned if the variable is unreadable.
+ *
+ * ```ts
+ * env("ENV_VAR", { default: "foo" })
+ * ```
+ */ export declare function env(key: string, options?: {
+  boolean?: false;
+  default?: string;
+}): string;
+/**
+ * Reads an environment variable and converts it to a boolean.
+ *
+ * Any non-empty string is considered truthy, except for:
+ * - Values matching falsy definition in {@link https://yaml.org/type/bool.html | YAML 1.1 specification}
+ * - Zero-valued strings after a number conversion
+ *
+ * A falsy value is returned if the variable is unreadable.
+ *
+ * ```ts
+ * env("ENV_VAR", { boolean: true, default: "false" })
+ * ```
+ */ export declare function env(key: string, options: {
+  boolean: true;
+  default?: string;
+}): boolean;

package/env.js

@@ -0,0 +1,28 @@
+/**
+ * Reads an environment variable.
+ *
+ * An empty string is returned if the variable is unreadable.
+ *
+ * ```ts
+ * env("ENV_VAR", { default: "foo" })
+ * ```
+ */ export function env(key, { boolean = false, default: _default = "" } = {}) {
+  if (boolean) {
+    const value = env(key, {
+      boolean: false,
+      default: _default
+    });
+    if (+value === 0) return false;
+    return !/^([Nn]o?|NO|[Oo]ff|OFF|[Ff]alse|FALSE)$/.test(value);
+  }
+  try {
+    if (Deno.permissions.querySync({
+      name: "env",
+      variable: key
+    }).state !== "granted") return _default;
+    return Deno.env.get(key) || _default;
+  } catch  {
+    return _default;
+  }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/evaluate.d.ts

@@ -0,0 +1,49 @@
+/** Evaluate an expression and return a string. */ export declare function evaluate(expression: string, context: Readonly<Record<PropertyKey, unknown>>, options: EvaluateOptions & {
+  sync: true;
+  return: typeof EvaluationReturn.String;
+}): string;
+/** Evaluate an expression and return a boolean. */ export declare function evaluate(expression: string, context: Readonly<Record<PropertyKey, unknown>>, options: EvaluateOptions & {
+  sync: true;
+  return: typeof EvaluationReturn.Boolean;
+}): boolean;
+/** Evaluate an expression against a context. */ export declare function evaluate(expression: string, context?: Readonly<Record<PropertyKey, unknown>>, options?: EvaluateOptions & {
+  sync: true;
+}): unknown;
+/** Evaluate an expression and return a string. */ export declare function evaluate(expression: string, context: Readonly<Record<PropertyKey, unknown>>, options: EvaluateOptions & {
+  sync?: false;
+  return: typeof EvaluationReturn.String;
+}): Promise<string>;
+/** Evaluate an expression and return a boolean. */ export declare function evaluate(expression: string, context: Readonly<Record<PropertyKey, unknown>>, options: EvaluateOptions & {
+  sync?: false;
+  return: typeof EvaluationReturn.Boolean;
+}): Promise<boolean>;
+/**
+ * Evaluate an expression against a context.
+ *
+ * The context is exposed to the expression through a `with` scope, meaning its entries can be referenced directly by name.
+ *
+ * ```ts
+ * import { evaluate } from "./evaluate.ts"
+ * console.assert(await evaluate("${a + b}", { a: 1, b: 2 }) === 3)
+ * console.assert(await evaluate("foo${a}", { a: "bar" }) === "foobar")
+ * ```
+ */ export declare function evaluate(expression: string, context?: Readonly<Record<PropertyKey, unknown>>, options?: EvaluateOptions & {
+  sync?: false;
+}): Promise<unknown>;
+/** Syntaxes supported by {@linkcode evaluate()}. */ export declare enum EvaluationSyntax {
+  /** Treat the expression as an implicit template literal: expressions wrapped in `${...}` are evaluated, anything else is returned as-is. */ Template,
+  /** Treat the expression as a single JavaScript expression. */ Block,
+  /** Treat the expression as an asynchronous function body, where `return` statements yield the result. */ Function
+}
+/** Coercions applicable to an {@linkcode evaluate()} result. */ export declare enum EvaluationReturn {
+  /** Return the result as-is. */ Unknown,
+  /** Coerce the result to a boolean. */ Boolean,
+  /** Coerce the result to a string. */ String
+}
+/** Options for {@linkcode evaluate()}. */ export type EvaluateOptions = {
+  /** Code evaluated before the expression, useful to declare constants or helper functions. */ preload?: string;
+  /** Syntax used to interpret the expression (defaults to {@linkcode EvaluationSyntax.Template}). */ syntax?: EvaluationSyntax;
+  /** Coercion applied to the result (defaults to {@linkcode EvaluationReturn.Unknown}). */ return?: EvaluationReturn;
+  /** Abort signal (ignored if running in sync mode). */ signal?: AbortSignal;
+  /** Whether to evaluate in a synchronous manner. */ sync?: boolean;
+};

package/evaluate.js

@@ -0,0 +1,90 @@
+// Imports
+import { AsyncFunction } from "@lowlighter/typing/func";
+/** Reserved identifier used internally by {@linkcode evaluate()} to share state with the evaluated expression. */ const reserved = "__evaluate__";
+export function evaluate(expression, context = {}, { sync = false, preload, syntax = EvaluationSyntax.Template, return: coerce, signal } = {}) {
+  // Check whether the expression needs to be executed
+  let execute = syntax !== EvaluationSyntax.Template;
+  if (syntax === EvaluationSyntax.Template) {
+    // Unwrap expressions of the form `${...}`
+    if (expression.startsWith("${") && expression.endsWith("}") && coerce !== EvaluationReturn.String) {
+      let depth = 1;
+      let i = 2;
+      for(; i < expression.length && depth > 0; i++)depth += expression[i] === "{" ? 1 : expression[i] === "}" ? -1 : 0;
+      if (depth === 0 && i === expression.length) {
+        expression = expression.slice(2, -1).trim();
+        execute = true;
+      }
+    }
+    // Quote implicit template literals
+    if (!execute && /\$\{[\s\S]*\}/.test(expression)) {
+      expression = `\`${expression}\``;
+      execute = true;
+    }
+  }
+  if (!execute) return sync ? expression : Promise.resolve(expression);
+  // Prevent internal state corruption from namespace collisions
+  if (reserved in context) {
+    const error = new ReferenceError(`"${reserved}" is a reserved variable name`);
+    if (sync) throw error;
+    return Promise.reject(error);
+  }
+  // Evaluate the expression
+  if (sync) {
+    try {
+      if (syntax === EvaluationSyntax.Function) expression = `(()=>{${expression}})()`;
+      const fn = new Function(reserved, `${preload};with(${reserved}.context){${reserved}.result=${expression}}return ${reserved}.result`);
+      const result = fn({
+        context,
+        result: undefined
+      });
+      return coerce === EvaluationReturn.String ? `${result}` : coerce === EvaluationReturn.Boolean ? !!result : result;
+    } catch (error) {
+      if (error instanceof Error) delete error.stack;
+      throw error;
+    }
+  }
+  if (syntax === EvaluationSyntax.Function) expression = `await(async()=>{${expression}})()`;
+  return (async ()=>{
+    const fn = new AsyncFunction(reserved, `${preload};with(${reserved}.context){${reserved}.result=${expression}}return ${reserved}.result`);
+    const result = await abortable(fn({
+      context,
+      result: undefined
+    }), signal);
+    return coerce === EvaluationReturn.String ? `${result}` : coerce === EvaluationReturn.Boolean ? !!result : result;
+  })().catch((error)=>{
+    if (error instanceof Error) delete error.stack;
+    throw error;
+  });
+}
+/** Race a promise against an abort signal, rejecting with the signal reason upon abortion. */ async function abortable(promise, signal) {
+  if (!signal) return promise;
+  const { promise: aborted, reject } = Promise.withResolvers();
+  const onabort = ()=>reject(signal.reason);
+  signal.addEventListener("abort", onabort, {
+    once: true
+  });
+  try {
+    signal.throwIfAborted();
+    return await Promise.race([
+      promise,
+      aborted
+    ]);
+  } finally{
+    signal.removeEventListener("abort", onabort);
+    // Mark a possible late settlement as handled to avoid unhandled rejections after abortion
+    promise.catch(()=>{});
+  }
+}
+/** Syntaxes supported by {@linkcode evaluate()}. */ export var EvaluationSyntax = /*#__PURE__*/ function(EvaluationSyntax) {
+  /** Treat the expression as an implicit template literal: expressions wrapped in `${...}` are evaluated, anything else is returned as-is. */ EvaluationSyntax[EvaluationSyntax["Template"] = 0] = "Template";
+  /** Treat the expression as a single JavaScript expression. */ EvaluationSyntax[EvaluationSyntax["Block"] = 1] = "Block";
+  /** Treat the expression as an asynchronous function body, where `return` statements yield the result. */ EvaluationSyntax[EvaluationSyntax["Function"] = 2] = "Function";
+  return EvaluationSyntax;
+}({});
+/** Coercions applicable to an {@linkcode evaluate()} result. */ export var EvaluationReturn = /*#__PURE__*/ function(EvaluationReturn) {
+  /** Return the result as-is. */ EvaluationReturn[EvaluationReturn["Unknown"] = 0] = "Unknown";
+  /** Coerce the result to a boolean. */ EvaluationReturn[EvaluationReturn["Boolean"] = 1] = "Boolean";
+  /** Coerce the result to a string. */ EvaluationReturn[EvaluationReturn["String"] = 2] = "String";
+  return EvaluationReturn;
+}({});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/libs/libs/@libs/toolbox/evaluate.ts"],"sourcesContent":["// Imports\nimport { AsyncFunction } from \"@libs/typing/func\"\n\n/** Reserved identifier used internally by {@linkcode evaluate()} to share state with the evaluated expression. */\nconst reserved = \"__evaluate__\"\n\n/** Evaluate an expression and return a string. */\nexport function evaluate(expression: string, context: Readonly<Record<PropertyKey, unknown>>, options: EvaluateOptions & { sync: true; return: typeof EvaluationReturn.String }): string\n/** Evaluate an expression and return a boolean. */\nexport function evaluate(expression: string, context: Readonly<Record<PropertyKey, unknown>>, options: EvaluateOptions & { sync: true; return: typeof EvaluationReturn.Boolean }): boolean\n/** Evaluate an expression against a context. */\nexport function evaluate(expression: string, context?: Readonly<Record<PropertyKey, unknown>>, options?: EvaluateOptions & { sync: true }): unknown\n/** Evaluate an expression and return a string. */\nexport async function evaluate(expression: string, context: Readonly<Record<PropertyKey, unknown>>, options: EvaluateOptions & { sync?: false; return: typeof EvaluationReturn.String }): Promise<string>\n/** Evaluate an expression and return a boolean. */\nexport async function evaluate(expression: string, context: Readonly<Record<PropertyKey, unknown>>, options: EvaluateOptions & { sync?: false; return: typeof EvaluationReturn.Boolean }): Promise<boolean>\n/**\n * Evaluate an expression against a context.\n *\n * The context is exposed to the expression through a `with` scope, meaning its entries can be referenced directly by name.\n *\n * ```ts\n * import { evaluate } from \"./evaluate.ts\"\n * console.assert(await evaluate(\"${a + b}\", { a: 1, b: 2 }) === 3)\n * console.assert(await evaluate(\"foo${a}\", { a: \"bar\" }) === \"foobar\")\n * ```\n */\nexport function evaluate(expression: string, context?: Readonly<Record<PropertyKey, unknown>>, options?: EvaluateOptions & { sync?: false }): Promise<unknown>\nexport function evaluate(expression: string, context: Readonly<Record<PropertyKey, unknown>> = {}, { sync = false, preload, syntax = EvaluationSyntax.Template, return: coerce, signal }: EvaluateOptions = {}) {\n  // Check whether the expression needs to be executed\n  let execute = syntax !== EvaluationSyntax.Template\n  if (syntax === EvaluationSyntax.Template) {\n    // Unwrap expressions of the form `${...}`\n    if (expression.startsWith(\"${\") && expression.endsWith(\"}\") && (coerce !== EvaluationReturn.String)) {\n      let depth = 1\n      let i = 2\n      for (; (i < expression.length) && (depth > 0); i++)\n        depth += (expression[i] === \"{\") ? 1 : (expression[i] === \"}\") ? -1 : 0\n      if ((depth === 0) && (i === expression.length)) {\n        expression = expression.slice(2, -1).trim()\n        execute = true\n      }\n    }\n    // Quote implicit template literals\n    if ((!execute) && (/\\$\\{[\\s\\S]*\\}/.test(expression))) {\n      expression = `\\`${expression}\\``\n      execute = true\n    }\n  }\n  if (!execute)\n    return sync ? expression : Promise.resolve(expression)\n\n  // Prevent internal state corruption from namespace collisions\n  if (reserved in context) {\n    const error = new ReferenceError(`\"${reserved}\" is a reserved variable name`)\n    if (sync)\n      throw error\n    return Promise.reject(error)\n  }\n\n  // Evaluate the expression\n  if (sync) {\n    try {\n      if (syntax === EvaluationSyntax.Function)\n        expression = `(()=>{${expression}})()`\n      const fn = new Function(reserved, `${preload};with(${reserved}.context){${reserved}.result=${expression}}return ${reserved}.result`)\n      const result = fn({ context, result: undefined })\n      return coerce === EvaluationReturn.String ? `${result}` : coerce === EvaluationReturn.Boolean ? !!result : result\n    } catch (error) {\n      if (error instanceof Error)\n        delete error.stack\n      throw error\n    }\n  }\n  if (syntax === EvaluationSyntax.Function)\n    expression = `await(async()=>{${expression}})()`\n  return (async () => {\n    const fn = new AsyncFunction(reserved, `${preload};with(${reserved}.context){${reserved}.result=${expression}}return ${reserved}.result`)\n    const result = await abortable(fn({ context, result: undefined }), signal)\n    return coerce === EvaluationReturn.String ? `${result}` : coerce === EvaluationReturn.Boolean ? !!result : result\n  })().catch((error) => {\n    if (error instanceof Error)\n      delete error.stack\n    throw error\n  })\n}\n\n/** Race a promise against an abort signal, rejecting with the signal reason upon abortion. */\nasync function abortable<T>(promise: Promise<T>, signal?: AbortSignal): Promise<T> {\n  if (!signal)\n    return promise\n  const { promise: aborted, reject } = Promise.withResolvers<never>()\n  const onabort = () => reject(signal.reason)\n  signal.addEventListener(\"abort\", onabort, { once: true })\n  try {\n    signal.throwIfAborted()\n    return await Promise.race([promise, aborted])\n  } finally {\n    signal.removeEventListener(\"abort\", onabort)\n    // Mark a possible late settlement as handled to avoid unhandled rejections after abortion\n    promise.catch(() => {})\n  }\n}\n\n/** Syntaxes supported by {@linkcode evaluate()}. */\nexport enum EvaluationSyntax {\n  /** Treat the expression as an implicit template literal: expressions wrapped in `${...}` are evaluated, anything else is returned as-is. */\n  Template,\n  /** Treat the expression as a single JavaScript expression. */\n  Block,\n  /** Treat the expression as an asynchronous function body, where `return` statements yield the result. */\n  Function,\n}\n\n/** Coercions applicable to an {@linkcode evaluate()} result. */\nexport enum EvaluationReturn {\n  /** Return the result as-is. */\n  Unknown,\n  /** Coerce the result to a boolean. */\n  Boolean,\n  /** Coerce the result to a string. */\n  String,\n}\n\n/** Options for {@linkcode evaluate()}. */\nexport type EvaluateOptions = {\n  /** Code evaluated before the expression, useful to declare constants or helper functions. */\n  preload?: string\n  /** Syntax used to interpret the expression (defaults to {@linkcode EvaluationSyntax.Template}). */\n  syntax?: EvaluationSyntax\n  /** Coercion applied to the result (defaults to {@linkcode EvaluationReturn.Unknown}). */\n  return?: EvaluationReturn\n  /** Abort signal (ignored if running in sync mode). */\n  signal?: AbortSignal\n  /** Whether to evaluate in a synchronous manner. */\n  sync?: boolean\n}\n"],"names":[],"mappings":"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"}

package/events.d.ts

@@ -0,0 +1,8 @@
+/** An event emitter with strongly-typed event data. */ export declare class EventEmitter<T = unknown> {
+  /** Registers a listener for the specified event. */ on(event: string, listener: Listener<T>, {}?: {
+  }): void;
+  /** Unregisters all listeners for the specified event. */ off(event: string): void;
+  /** Unregisters a listener for the specified event. */ off(event: string, listener: Listener<T>): void;
+  /** Emits an event with the specified data. */ emit(event: string, data: T): void;
+}
+/** A listener invoked with the emitted event data. */ export type Listener<T = unknown> = (data: T) => void;

package/events.js

@@ -0,0 +1,28 @@
+/** An event emitter with strongly-typed event data. */ export class EventEmitter {
+  /** Registered listeners mapped to their wrappers. */ #listeners = new Map();
+  /** Registers a listener for the specified event. */ on(event, listener, { once = false } = {}) {
+    const listeners = this.#listeners.getOrInsert(event, new Map());
+    if (!listeners.has(listener)) listeners.set(listener, once ? (data)=>listener(data) : listener);
+  }
+  off(event, listener) {
+    const listeners = this.#listeners.get(event);
+    if (!listener) {
+      listeners?.clear();
+      return;
+    }
+    if (listeners?.has(listener)) listeners.delete(listener);
+  }
+  /** Emits an event with the specified data. */ emit(event, data) {
+    const listeners = this.#listeners.get(event);
+    if (!listeners) return;
+    // Snapshot registered listeners
+    for (const [listener, wrapper] of [
+      ...listeners
+    ]){
+      if (listeners.get(listener) !== wrapper) continue;
+      if (wrapper !== listener) listeners.delete(listener);
+      wrapper(data);
+    }
+  }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/filesystem.d.ts

@@ -0,0 +1,19 @@
+import type { Nullable } from "@lowlighter/typing";
+export type { Nullable };
+/** Gets the current working directory. */ export declare function cwd(): string;
+/** Changes the current working directory. */ export declare function chdir(path: string | URL): string;
+/** Gets the file type of a file path. */ export declare function filetype(path: string): Nullable<"file" | "directory">;
+/** Options for {@linkcode list()}. */ export type ListOptions = {
+  /** Root directory to search in. Defaults to the current working directory. */ root?: string;
+  /** Whether to return relative paths. */ relative?: boolean;
+  /** Whether to include files in the results. */ files?: boolean;
+  /** Whether to include directories in the results. */ directories?: boolean;
+  /** List of glob patterns to be excluded from the expansion. */ exclude?: string[];
+  /** Whether globstar should be case-insensitive. */ caseInsensitive?: boolean;
+  /** Whether to follow symbolic links. */ followSymlinks?: boolean;
+};
+/**
+ * Lists all entries matching the given glob pattern in the specified root directory.
+ *
+ * Note that `files` and `directories` both default to `false`, at least one of them must be enabled to get any result.
+ */ export declare function list(glob: string, {}?: ListOptions): Promise<string[]>;

package/filesystem.js

@@ -0,0 +1,40 @@
+// Imports
+import { expandGlob } from "@std/fs";
+/** Gets the current working directory. */ export function cwd() {
+  return Deno.cwd().replaceAll("\\", "/");
+}
+/** Changes the current working directory. */ export function chdir(path) {
+  Deno.chdir(path);
+  return cwd();
+}
+/** Gets the file type of a file path. */ export function filetype(path) {
+  try {
+    const lstat = Deno.lstatSync(path);
+    if (lstat.isFile) return "file";
+    if (lstat.isDirectory) return "directory";
+  } catch  {
+  // Ignore errors
+  }
+  return null;
+}
+/**
+ * Lists all entries matching the given glob pattern in the specified root directory.
+ *
+ * Note that `files` and `directories` both default to `false`, at least one of them must be enabled to get any result.
+ */ export async function list(glob, { root = cwd(), relative = true, files = false, directories = false, exclude, caseInsensitive, followSymlinks } = {}) {
+  root = root.replaceAll("\\", "/");
+  if (!root.endsWith("/")) root += "/";
+  const entries = await Array.fromAsync(expandGlob(glob, {
+    root,
+    canonicalize: true,
+    includeDirs: directories,
+    exclude,
+    caseInsensitive,
+    followSymlinks
+  }));
+  return entries.filter((entry)=>files && entry.isFile || directories && entry.isDirectory).map(({ path })=>{
+    path = path.replaceAll("\\", "/");
+    return relative && path.startsWith(root) ? path.slice(root.length) : path;
+  });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/fixtures/filesystem/a/b/foo.txt

@@ -0,0 +1 @@
+Lorem ipsum

package/fixtures/filesystem/a/c/bar.txt

@@ -0,0 +1 @@
+Lorem ipsum

package/fixtures/filesystem/a/c/baz.txt

@@ -0,0 +1 @@
+Lorem ipsum

package/fixtures/filesystem/a/d/qux.ts

@@ -0,0 +1 @@
+// Lorem ipsum

package/format.d.ts

@@ -0,0 +1,9 @@
+/** Format a country code as a flag emoji. */ export declare function countryFlag(code: string): string;
+/** Normalize string to uppercase and remove diacritics. */ export declare function unfd(string: string): string;
+/** Normalize string to lowercase and remove diacritics. */ export declare function lnfd(string: string): string;
+/**
+ * Strip emojis from a string.
+ *
+ * Keycap emojis are converted back to their base character
+ * and flag emojis back to their two-letter country code.
+ */ export declare function stripEmojis(string: string): string;

package/format.js

@@ -0,0 +1,21 @@
+/** Format a country code as a flag emoji. */ export function countryFlag(code) {
+  const cc = code.trim().toUpperCase();
+  if (!/^[A-Z]{2}$/.test(cc)) return code;
+  const A = 0x1f1e6;
+  return String.fromCodePoint(A + (cc.charCodeAt(0) - 65), A + (cc.charCodeAt(1) - 65));
+}
+/** Normalize string to uppercase and remove diacritics. */ export function unfd(string) {
+  return string.toLocaleUpperCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+}
+/** Normalize string to lowercase and remove diacritics. */ export function lnfd(string) {
+  return unfd(string).toLocaleLowerCase();
+}
+/**
+ * Strip emojis from a string.
+ *
+ * Keycap emojis are converted back to their base character
+ * and flag emojis back to their two-letter country code.
+ */ export function stripEmojis(string) {
+  return string.replace(/([#*0-9])\uFE0F?\u20E3/gu, "$1").replace(/\p{Regional_Indicator}/gu, (char)=>String.fromCharCode(char.codePointAt(0) - 0x1f1e6 + 65)).replace(/\p{Extended_Pictographic}(?:\uFE0F|\p{Emoji_Modifier}|\u200D\p{Extended_Pictographic})*/gu, "");
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImZpbGU6Ly8vaG9tZS9ydW5uZXIvd29yay9saWJzL2xpYnMvQGxpYnMvdG9vbGJveC9mb3JtYXQudHMiXSwic291cmNlc0NvbnRlbnQiOlsiLyoqIEZvcm1hdCBhIGNvdW50cnkgY29kZSBhcyBhIGZsYWcgZW1vamkuICovXG5leHBvcnQgZnVuY3Rpb24gY291bnRyeUZsYWcoY29kZTogc3RyaW5nKTogc3RyaW5nIHtcbiAgY29uc3QgY2MgPSBjb2RlLnRyaW0oKS50b1VwcGVyQ2FzZSgpXG4gIGlmICghL15bQS1aXXsyfSQvLnRlc3QoY2MpKVxuICAgIHJldHVybiBjb2RlXG4gIGNvbnN0IEEgPSAweDFmMWU2XG4gIHJldHVybiBTdHJpbmcuZnJvbUNvZGVQb2ludChBICsgKGNjLmNoYXJDb2RlQXQoMCkgLSA2NSksIEEgKyAoY2MuY2hhckNvZGVBdCgxKSAtIDY1KSlcbn1cblxuLyoqIE5vcm1hbGl6ZSBzdHJpbmcgdG8gdXBwZXJjYXNlIGFuZCByZW1vdmUgZGlhY3JpdGljcy4gKi9cbmV4cG9ydCBmdW5jdGlvbiB1bmZkKHN0cmluZzogc3RyaW5nKTogc3RyaW5nIHtcbiAgcmV0dXJuIHN0cmluZy50b0xvY2FsZVVwcGVyQ2FzZSgpLm5vcm1hbGl6ZShcIk5GRFwiKS5yZXBsYWNlKC9bXFx1MDMwMC1cXHUwMzZmXS9nLCBcIlwiKVxufVxuXG4vKiogTm9ybWFsaXplIHN0cmluZyB0byBsb3dlcmNhc2UgYW5kIHJlbW92ZSBkaWFjcml0aWNzLiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGxuZmQoc3RyaW5nOiBzdHJpbmcpOiBzdHJpbmcge1xuICByZXR1cm4gdW5mZChzdHJpbmcpLnRvTG9jYWxlTG93ZXJDYXNlKClcbn1cblxuLyoqXG4gKiBTdHJpcCBlbW9qaXMgZnJvbSBhIHN0cmluZy5cbiAqXG4gKiBLZXljYXAgZW1vamlzIGFyZSBjb252ZXJ0ZWQgYmFjayB0byB0aGVpciBiYXNlIGNoYXJhY3RlclxuICogYW5kIGZsYWcgZW1vamlzIGJhY2sgdG8gdGhlaXIgdHdvLWxldHRlciBjb3VudHJ5IGNvZGUuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBzdHJpcEVtb2ppcyhzdHJpbmc6IHN0cmluZyk6IHN0cmluZyB7XG4gIHJldHVybiBzdHJpbmdcbiAgICAucmVwbGFjZSgvKFsjKjAtOV0pXFx1RkUwRj9cXHUyMEUzL2d1LCBcIiQxXCIpXG4gICAgLnJlcGxhY2UoL1xccHtSZWdpb25hbF9JbmRpY2F0b3J9L2d1LCAoY2hhcikgPT4gU3RyaW5nLmZyb21DaGFyQ29kZShjaGFyLmNvZGVQb2ludEF0KDApISAtIDB4MWYxZTYgKyA2NSkpXG4gICAgLnJlcGxhY2UoL1xccHtFeHRlbmRlZF9QaWN0b2dyYXBoaWN9KD86XFx1RkUwRnxcXHB7RW1vamlfTW9kaWZpZXJ9fFxcdTIwMERcXHB7RXh0ZW5kZWRfUGljdG9ncmFwaGljfSkqL2d1LCBcIlwiKVxufVxuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLDJDQUEyQyxHQUMzQyxPQUFPLFNBQVMsWUFBWSxJQUFZO0VBQ3RDLE1BQU0sS0FBSyxLQUFLLElBQUksR0FBRyxXQUFXO0VBQ2xDLElBQUksQ0FBQyxhQUFhLElBQUksQ0FBQyxLQUNyQixPQUFPO0VBQ1QsTUFBTSxJQUFJO0VBQ1YsT0FBTyxPQUFPLGFBQWEsQ0FBQyxJQUFJLENBQUMsR0FBRyxVQUFVLENBQUMsS0FBSyxFQUFFLEdBQUcsSUFBSSxDQUFDLEdBQUcsVUFBVSxDQUFDLEtBQUssRUFBRTtBQUNyRjtBQUVBLHlEQUF5RCxHQUN6RCxPQUFPLFNBQVMsS0FBSyxNQUFjO0VBQ2pDLE9BQU8sT0FBTyxpQkFBaUIsR0FBRyxTQUFTLENBQUMsT0FBTyxPQUFPLENBQUMsb0JBQW9CO0FBQ2pGO0FBRUEseURBQXlELEdBQ3pELE9BQU8sU0FBUyxLQUFLLE1BQWM7RUFDakMsT0FBTyxLQUFLLFFBQVEsaUJBQWlCO0FBQ3ZDO0FBRUE7Ozs7O0NBS0MsR0FDRCxPQUFPLFNBQVMsWUFBWSxNQUFjO0VBQ3hDLE9BQU8sT0FDSixPQUFPLENBQUMsNEJBQTRCLE1BQ3BDLE9BQU8sQ0FBQyw0QkFBNEIsQ0FBQyxPQUFTLE9BQU8sWUFBWSxDQUFDLEtBQUssV0FBVyxDQUFDLEtBQU0sVUFBVSxLQUNuRyxPQUFPLENBQUMsNkZBQTZGO0FBQzFHIn0=

package/identicon.d.ts

@@ -0,0 +1,6 @@
+/**
+ * A deterministic identicon as an `svg+xml` data URL.
+ *
+ * A mirror-symmetric pixel grid with a seeded hue to generate  a simple recognisable default avatar.
+ */ export declare function identicon(seed: string, {}?: {
+}): string;

package/identicon.js

@@ -0,0 +1,32 @@
+/**
+ * A deterministic identicon as an `svg+xml` data URL.
+ *
+ * A mirror-symmetric pixel grid with a seeded hue to generate  a simple recognisable default avatar.
+ */ export function identicon(seed, { size = 5 } = {}) {
+  if (!Number.isInteger(size) || size <= 0) throw new RangeError(`Invalid identicon size: ${size}`);
+  // FNV-1a 32-bit hash of the seed
+  let h = 0x811c9dc5;
+  for(let i = 0; i < seed.length; i++){
+    h ^= seed.charCodeAt(i);
+    h = Math.imul(h, 0x01000193);
+  }
+  h >>>= 0;
+  const hue = h % 360;
+  const fg = `hsl(${hue} 58% 62%)`;
+  const bg = `hsl(${hue} 26% 18%)`;
+  // Seed an LCG from the hash
+  let r = h || 1;
+  const next = ()=>r = Math.imul(r, 1103515245) + 12345 >>> 0;
+  const cells = [];
+  for(let y = 0; y < size; y++){
+    for(let x = 0; x < Math.ceil(size / 2); x++){
+      if (next() & 0x10000) {
+        cells.push(`<rect x="${x}" y="${y}" width="1" height="1"/>`);
+        if (x < Math.floor(size / 2)) cells.push(`<rect x="${size - 1 - x}" y="${y}" width="1" height="1"/>`);
+      }
+    }
+  }
+  const svg = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${size} ${size}" ` + `shape-rendering="crispEdges"><rect width="${size}" height="${size}" fill="${bg}"/>` + `<g fill="${fg}">${cells.join("")}</g></svg>`;
+  return `data:image/svg+xml;base64,${btoa(svg)}`;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/imgb64.d.ts

@@ -0,0 +1 @@
+/** Download a remote PNG and return it as a base64 data URL. */ export declare function imgb64(url: string): Promise<string>;

package/imgb64.js

@@ -0,0 +1,15 @@
+import { encodeBase64 } from "@std/encoding/base64";
+/** Transparent 1x1 PNG data URL. */ const fallback = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAAAAAA6fptVAAAACklEQVQI12NgAAAAAgAB4iG8MwAAAABJRU5ErkJggg==";
+/** Download a remote PNG and return it as a base64 data URL. */ export async function imgb64(url) {
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      await response.body?.cancel();
+      return fallback;
+    }
+    return `data:image/png;base64,${encodeBase64(await response.arrayBuffer())}`;
+  } catch  {
+    return fallback;
+  }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImZpbGU6Ly8vaG9tZS9ydW5uZXIvd29yay9saWJzL2xpYnMvQGxpYnMvdG9vbGJveC9pbWdiNjQudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgZW5jb2RlQmFzZTY0IH0gZnJvbSBcIkBzdGQvZW5jb2RpbmcvYmFzZTY0XCJcblxuLyoqIFRyYW5zcGFyZW50IDF4MSBQTkcgZGF0YSBVUkwuICovXG5jb25zdCBmYWxsYmFjayA9IFwiZGF0YTppbWFnZS9wbmc7YmFzZTY0LGlWQk9SdzBLR2dvQUFBQU5TVWhFVWdBQUFBRUFBQUFCQ0FBQUFBQTZmcHRWQUFBQUNrbEVRVlFJMTJOZ0FBQUFBZ0FCNGlHOE13QUFBQUJKUlU1RXJrSmdnZz09XCJcblxuLyoqIERvd25sb2FkIGEgcmVtb3RlIFBORyBhbmQgcmV0dXJuIGl0IGFzIGEgYmFzZTY0IGRhdGEgVVJMLiAqL1xuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIGltZ2I2NCh1cmw6IHN0cmluZyk6IFByb21pc2U8c3RyaW5nPiB7XG4gIHRyeSB7XG4gICAgY29uc3QgcmVzcG9uc2UgPSBhd2FpdCBmZXRjaCh1cmwpXG4gICAgaWYgKCFyZXNwb25zZS5vaykge1xuICAgICAgYXdhaXQgcmVzcG9uc2UuYm9keT8uY2FuY2VsKClcbiAgICAgIHJldHVybiBmYWxsYmFja1xuICAgIH1cbiAgICByZXR1cm4gYGRhdGE6aW1hZ2UvcG5nO2Jhc2U2NCwke2VuY29kZUJhc2U2NChhd2FpdCByZXNwb25zZS5hcnJheUJ1ZmZlcigpKX1gXG4gIH0gY2F0Y2gge1xuICAgIHJldHVybiBmYWxsYmFja1xuICB9XG59XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsU0FBUyxZQUFZLFFBQVEsdUJBQXNCO0FBRW5ELGtDQUFrQyxHQUNsQyxNQUFNLFdBQVc7QUFFakIsOERBQThELEdBQzlELE9BQU8sZUFBZSxPQUFPLEdBQVc7RUFDdEMsSUFBSTtJQUNGLE1BQU0sV0FBVyxNQUFNLE1BQU07SUFDN0IsSUFBSSxDQUFDLFNBQVMsRUFBRSxFQUFFO01BQ2hCLE1BQU0sU0FBUyxJQUFJLEVBQUU7TUFDckIsT0FBTztJQUNUO0lBQ0EsT0FBTyxDQUFDLHNCQUFzQixFQUFFLGFBQWEsTUFBTSxTQUFTLFdBQVcsS0FBSztFQUM5RSxFQUFFLE9BQU07SUFDTixPQUFPO0VBQ1Q7QUFDRiJ9

package/mod.ts

@@ -0,0 +1 @@
+// No default exports

package/noop.d.ts

@@ -0,0 +1 @@
+/** No operation. */ export declare function noop(): void;

package/noop.js

@@ -0,0 +1,2 @@
+/** No operation. */ export function noop() {}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImZpbGU6Ly8vaG9tZS9ydW5uZXIvd29yay9saWJzL2xpYnMvQGxpYnMvdG9vbGJveC9ub29wLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8qKiBObyBvcGVyYXRpb24uICovXG5leHBvcnQgZnVuY3Rpb24gbm9vcCgpOiB2b2lkIHt9XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsa0JBQWtCLEdBQ2xCLE9BQU8sU0FBUyxRQUFjIn0=