@poppinss/utils 6.5.0-3 → 6.5.0-5

package/README.md

@@ -557,6 +557,7 @@ string.bytes.format(1024 * 1024 * 1000, { thousandsSeparator: ',' }) // 1,000MB
 ```
 
 ### String builder
+
 The string builder offers a fluent API for applying a set of transforms on a string value. You can create an instance of the string builder as follows.
 
 ```ts
@@ -938,6 +939,7 @@ await Promise.all(
 ```
 
 #### importDefault
+
 A helper function that assert a lazy import function output to have a `default export`, otherwise raises an exception.
 
 We use dynamic default exports a lot in AdonisJS apps, so extracting the check to a helper function.

package/build/chunk-OKRMWJO4.js

@@ -0,0 +1,269 @@
+import {
+  base64,
+  milliseconds_default
+} from "./chunk-PWRXO3NF.js";
+
+// src/string/bytes.ts
+import bytes from "bytes";
+var bytes_default = {
+  format(valueInBytes, options) {
+    return bytes.format(valueInBytes, options);
+  },
+  /**
+   * Parse the unit expression to bytes. If the unit value
+   * is a number, then it will be returned as it is considering
+   * it is already in bytes.
+   */
+  parse(unit) {
+    if (typeof unit === "number") {
+      return unit;
+    }
+    return bytes.parse(unit);
+  }
+};
+
+// src/string/seconds.ts
+import { parse, format } from "@lukeed/ms";
+var seconds_default = {
+  format(seconds, long) {
+    return format(seconds * 1e3, long);
+  },
+  /**
+   * Parse time expression string to seconds. The number value
+   * is returned as it is, considering it is already in seconds
+   */
+  parse(duration) {
+    if (typeof duration === "number") {
+      return duration;
+    }
+    const milliseconds = parse(duration);
+    if (milliseconds === void 0) {
+      throw new Error(`Invalid duration expression "${duration}"`);
+    }
+    return Math.floor(milliseconds / 1e3);
+  }
+};
+
+// src/string/slugify.ts
+import { default as slugifyPkg } from "slugify";
+var slug = slugifyPkg;
+
+// src/string/random.ts
+import { randomBytes } from "node:crypto";
+function random(size) {
+  const bits = (size + 1) * 6;
+  const buffer = randomBytes(Math.ceil(bits / 8));
+  return base64.urlEncode(buffer).slice(0, size);
+}
+
+// src/string/excerpt.ts
+import truncatise from "truncatise";
+function excerpt(sentence2, charactersLimit, options) {
+  return truncatise(sentence2, {
+    TruncateLength: charactersLimit,
+    /**
+     * Do not complete words when "completeWords" is not explicitly set
+     * to true
+     */
+    Strict: options && options.completeWords === true ? false : true,
+    StripHTML: true,
+    TruncateBy: "characters",
+    Suffix: options && options.suffix
+  });
+}
+
+// src/string/ordinal.ts
+function ordinal(value) {
+  const transformedValue = Math.abs(typeof value === "string" ? Number.parseInt(value) : value);
+  if (!Number.isFinite(transformedValue) || Number.isNaN(transformedValue)) {
+    throw new Error("Cannot ordinalize invalid or infinite numbers");
+  }
+  const percent = transformedValue % 100;
+  if (percent >= 10 && percent <= 20) {
+    return `${value}th`;
+  }
+  const decimal = transformedValue % 10;
+  switch (decimal) {
+    case 1:
+      return `${value}st`;
+    case 2:
+      return `${value}nd`;
+    case 3:
+      return `${value}rd`;
+    default:
+      return `${value}th`;
+  }
+}
+
+// src/string/truncate.ts
+import truncatise2 from "truncatise";
+function truncate(sentence2, charactersLimit, options) {
+  return truncatise2(sentence2, {
+    TruncateLength: charactersLimit,
+    /**
+     * Do not complete words when "completeWords" is not explicitly set
+     * to true
+     */
+    Strict: options && options.completeWords === true ? false : true,
+    StripHTML: false,
+    TruncateBy: "characters",
+    Suffix: options && options.suffix
+  });
+}
+
+// src/string/sentence.ts
+function sentence(values, options) {
+  if (values.length === 0) {
+    return "";
+  }
+  if (values.length === 1) {
+    return values[0];
+  }
+  if (values.length === 2) {
+    return `${values[0]}${options?.pairSeparator || " and "}${values[1]}`;
+  }
+  const normalized = Object.assign({ separator: ", ", lastSeparator: ", and " }, options);
+  return `${values.slice(0, -1).join(normalized.separator)}${normalized.lastSeparator}${values[values.length - 1]}`;
+}
+
+// src/string/interpolate.ts
+function parseProp(data, key) {
+  const tokens = key.split(".");
+  while (tokens.length) {
+    if (data === null || typeof data !== "object") {
+      return;
+    }
+    const token = tokens.shift();
+    data = Object.hasOwn(data, token) ? data[token] : void 0;
+  }
+  return data;
+}
+function interpolate(input, data) {
+  return input.replace(/(\\)?{{(.*?)}}/g, (_, escapeChar, key) => {
+    if (escapeChar) {
+      return `{{${key}}}`;
+    }
+    return parseProp(data, key.trim());
+  });
+}
+
+// src/string/pluralize.ts
+import { default as pluralizePkg } from "pluralize";
+function pluralize(word, count, inclusive) {
+  return pluralizePkg(word, count, inclusive);
+}
+pluralize.addPluralRule = pluralizePkg.addPluralRule;
+pluralize.addSingularRule = pluralizePkg.addSingularRule;
+pluralize.addIrregularRule = pluralizePkg.addIrregularRule;
+pluralize.addUncountableRule = pluralizePkg.addUncountableRule;
+var plural = pluralizePkg.plural;
+var singular = pluralizePkg.singular;
+var isPlural = pluralizePkg.isPlural;
+var isSingular = pluralizePkg.isSingular;
+
+// src/string/change_case.ts
+import * as changeCase from "case-anything";
+var NO_CASE_SPLIT_REGEXP = [/([a-z0-9])([A-Z])/g, /([A-Z])([A-Z][a-z])/g];
+var NO_CASE_STRIP_REGEXP = /[^A-Z0-9]+/gi;
+var SMALL_WORDS = /\b(?:an?d?|a[st]|because|but|by|en|for|i[fn]|neither|nor|o[fnr]|only|over|per|so|some|tha[tn]|the|to|up|upon|vs?\.?|versus|via|when|with|without|yet)\b/i;
+var TOKENS = /[^\s:–—-]+|./g;
+var WHITESPACE = /\s/;
+var IS_MANUAL_CASE = /.(?=[A-Z]|\..)/;
+var ALPHANUMERIC_PATTERN = /[A-Za-z0-9\u00C0-\u00FF]/;
+function titleCase(input) {
+  let output = "";
+  let result;
+  while ((result = TOKENS.exec(input)) !== null) {
+    const { 0: token, index } = result;
+    if (!IS_MANUAL_CASE.test(token) && (!SMALL_WORDS.test(token) || index === 0 || index + token.length === input.length) && (input.charAt(index + token.length) !== ":" || WHITESPACE.test(input.charAt(index + token.length + 1)))) {
+      output += token.replace(ALPHANUMERIC_PATTERN, (char) => char.toUpperCase());
+      continue;
+    }
+    output += token;
+  }
+  return output;
+}
+function camelCase2(value) {
+  return changeCase.camelCase(value);
+}
+function snakeCase2(value) {
+  return changeCase.snakeCase(value);
+}
+function dashCase(value, options) {
+  if (options && options.capitalize) {
+    return changeCase.trainCase(value);
+  }
+  return changeCase.kebabCase(value);
+}
+function pascalCase2(value) {
+  return changeCase.pascalCase(value);
+}
+function capitalCase2(value) {
+  return changeCase.capitalCase(value);
+}
+function sentenceCase(value) {
+  return noCase(value, (input, index) => {
+    const result = input.toLowerCase();
+    if (index === 0) {
+      return input.charAt(0).toUpperCase() + input.substring(1);
+    }
+    return result;
+  });
+}
+function dotCase(value, options) {
+  const transformedValue = changeCase.dotNotation(value);
+  if (options && options.lowerCase) {
+    return transformedValue.toLowerCase();
+  }
+  return transformedValue;
+}
+function noCase(value, transform) {
+  let result = NO_CASE_SPLIT_REGEXP.reduce((input, regex) => input.replace(regex, "$1\0$2"), value);
+  result = result.replace(NO_CASE_STRIP_REGEXP, "\0");
+  let start = 0;
+  let end = result.length;
+  while (result.charAt(start) === "\0") {
+    start++;
+  }
+  while (result.charAt(end - 1) === "\0") {
+    end--;
+  }
+  return result.slice(start, end).split("\0").map(transform || ((input) => input.toLowerCase())).join(" ");
+}
+
+// src/string/main.ts
+function condenseWhitespace(value) {
+  return value.trim().replace(/\s{2,}/g, " ");
+}
+var string = {
+  excerpt,
+  truncate,
+  slug,
+  interpolate,
+  plural,
+  pluralize,
+  singular,
+  isPlural,
+  isSingular,
+  camelCase: camelCase2,
+  capitalCase: capitalCase2,
+  dashCase,
+  dotCase,
+  noCase,
+  pascalCase: pascalCase2,
+  sentenceCase,
+  snakeCase: snakeCase2,
+  titleCase,
+  random,
+  sentence,
+  condenseWhitespace,
+  seconds: seconds_default,
+  milliseconds: milliseconds_default,
+  bytes: bytes_default,
+  ordinal
+};
+var main_default = string;
+
+export {
+  main_default
+};

package/build/chunk-PWRXO3NF.js

@@ -0,0 +1,63 @@
+// src/base64.ts
+var Base64 = class {
+  encode(data, encoding) {
+    if (typeof data === "string") {
+      return Buffer.from(data, encoding).toString("base64");
+    }
+    return Buffer.from(data).toString("base64");
+  }
+  decode(encoded, encoding = "utf-8", strict = false) {
+    if (Buffer.isBuffer(encoded)) {
+      return encoded.toString(encoding);
+    }
+    const decoded = Buffer.from(encoded, "base64").toString(encoding);
+    const isInvalid = this.encode(decoded, encoding) !== encoded;
+    if (strict && isInvalid) {
+      throw new Error("Cannot decode malformed value");
+    }
+    return isInvalid ? null : decoded;
+  }
+  urlEncode(data, encoding) {
+    const encoded = typeof data === "string" ? this.encode(data, encoding) : this.encode(data);
+    return encoded.replace(/\+/g, "-").replace(/\//g, "_").replace(/\=/g, "");
+  }
+  urlDecode(encoded, encoding = "utf-8", strict = false) {
+    if (Buffer.isBuffer(encoded)) {
+      return encoded.toString(encoding);
+    }
+    const decoded = Buffer.from(encoded, "base64").toString(encoding);
+    const isInvalid = this.urlEncode(decoded, encoding) !== encoded;
+    if (strict && isInvalid) {
+      throw new Error("Cannot urlDecode malformed value");
+    }
+    return isInvalid ? null : decoded;
+  }
+};
+var base64 = new Base64();
+
+// src/string/milliseconds.ts
+import { parse, format } from "@lukeed/ms";
+var milliseconds_default = {
+  format(milliseconds, long) {
+    return format(milliseconds, long);
+  },
+  /**
+   * Parse time expression string to milliseconds. The number value
+   * is returned as it is, considering it is already in milliseconds
+   */
+  parse(duration) {
+    if (typeof duration === "number") {
+      return duration;
+    }
+    const milliseconds = parse(duration);
+    if (milliseconds === void 0) {
+      throw new Error(`Invalid duration expression "${duration}"`);
+    }
+    return milliseconds;
+  }
+};
+
+export {
+  base64,
+  milliseconds_default
+};

package/build/chunk-XHQBV7AF.js

@@ -0,0 +1,39 @@
+// src/json/safe_parse.ts
+import { parse } from "secure-json-parse";
+function safeParse(jsonString, reviver) {
+  return parse(jsonString, reviver, {
+    protoAction: "remove",
+    constructorAction: "remove"
+  });
+}
+
+// src/json/safe_stringify.ts
+import { configure } from "safe-stable-stringify";
+var stringify = configure({
+  bigint: false,
+  circularValue: void 0,
+  deterministic: false
+});
+function jsonStringifyReplacer(replacer) {
+  return function(key, value) {
+    const val = replacer ? replacer.call(this, key, value) : value;
+    if (typeof val === "bigint") {
+      return val.toString();
+    }
+    return val;
+  };
+}
+function safeStringify(value, replacer, space) {
+  return stringify(value, jsonStringifyReplacer(replacer), space);
+}
+
+// src/json/main.ts
+var json = {
+  safeParse,
+  safeStringify
+};
+var main_default = json;
+
+export {
+  main_default
+};

package/build/index.d.ts

@@ -1,19 +1,284 @@
-/// <reference types="@types/node" resolution-mode="require"/>
-export { base64 } from './src/base64.js';
-export { compose } from './src/compose.js';
-export { importDefault } from './src/import_default.js';
-export { defineStaticProperty } from './src/define_static_property.js';
-export { Exception, createError } from './src/exception.js';
-export { flatten } from './src/flatten.js';
-export { fsImportAll } from './src/fs_import_all.js';
-export { fsReadAll } from './src/fs_read_all.js';
-export { isScriptFile } from './src/is_script_file.js';
-export { MessageBuilder } from './src/message_builder.js';
-export { naturalSort } from './src/natural_sort.js';
-export { ObjectBuilder } from './src/object_builder.js';
-export { safeEqual } from './src/safe_equal.js';
-export { slash } from './src/slash.js';
-export { RuntimeException } from './src/exceptions/runtime_exception.js';
-export { InvalidArgumentsException } from './src/exceptions/invalid_arguments_exception.js';
-export declare function getDirname(url: string | URL): string;
-export declare function getFilename(url: string | URL): string;
+import { Constructor as Constructor$1, ImportAllFilesOptions, ReadAllFilesOptions, OmitProperties } from './src/types.js';
+export { default as slash } from 'slash';
+
+/**
+ * Helper class to base64 encode/decode values with option
+ * for url encoding and decoding
+ */
+declare class Base64 {
+    /**
+     * Base64 encode Buffer or string
+     */
+    encode(arrayBuffer: ArrayBuffer | SharedArrayBuffer): string;
+    encode(data: string, encoding?: BufferEncoding): string;
+    /**
+     * Base64 decode a previously encoded string or Buffer.
+     */
+    decode(encode: string, encoding: BufferEncoding, strict: true): string;
+    decode(encode: string, encoding: undefined, strict: true): string;
+    decode(encode: string, encoding?: BufferEncoding, strict?: false): string | null;
+    decode(encode: Buffer, encoding?: BufferEncoding): string;
+    /**
+     * Base64 encode Buffer or string to be URL safe. (RFC 4648)
+     */
+    urlEncode(arrayBuffer: ArrayBuffer | SharedArrayBuffer): string;
+    urlEncode(data: string, encoding?: BufferEncoding): string;
+    /**
+     * Base64 URL decode a previously encoded string or Buffer. (RFC 4648)
+     */
+    urlDecode(encode: string, encoding: BufferEncoding, strict: true): string;
+    urlDecode(encode: string, encoding: undefined, strict: true): string;
+    urlDecode(encode: string, encoding?: BufferEncoding, strict?: false): string | null;
+    urlDecode(encode: Buffer, encoding?: BufferEncoding): string;
+}
+declare const base64: Base64;
+
+interface UnaryFunction<T, R> {
+    (source: T): R;
+}
+/**
+ * Compose a class by applying mixins to it.
+ * The code is inspired by https://justinfagnani.com/2015/12/21/real-mixins-with-javascript-classes/, its
+ * just that I have added the support for static types too.
+ */
+declare function compose<T extends Constructor$1, A>(superclass: T, mixin: UnaryFunction<T, A>): A;
+declare function compose<T extends Constructor$1, A, B>(superclass: T, mixin: UnaryFunction<T, A>, mixinB: UnaryFunction<A, B>): B;
+declare function compose<T extends Constructor$1, A, B, C>(superclass: T, mixin: UnaryFunction<T, A>, mixinB: UnaryFunction<A, B>, mixinC: UnaryFunction<B, C>): C;
+declare function compose<T extends Constructor$1, A, B, C, D>(superclass: T, mixin: UnaryFunction<T, A>, mixinB: UnaryFunction<A, B>, mixinC: UnaryFunction<B, C>, mixinD: UnaryFunction<C, D>): D;
+declare function compose<T extends Constructor$1, A, B, C, D, E>(superclass: T, mixin: UnaryFunction<T, A>, mixinB: UnaryFunction<A, B>, mixinC: UnaryFunction<B, C>, mixinD: UnaryFunction<C, D>, mixinE: UnaryFunction<D, E>): E;
+declare function compose<T extends Constructor$1, A, B, C, D, E, F>(superclass: T, mixin: UnaryFunction<T, A>, mixinB: UnaryFunction<A, B>, mixinC: UnaryFunction<B, C>, mixinD: UnaryFunction<C, D>, mixinF: UnaryFunction<E, F>): F;
+declare function compose<T extends Constructor$1, A, B, C, D, E, F, G>(superclass: T, mixin: UnaryFunction<T, A>, mixinB: UnaryFunction<A, B>, mixinC: UnaryFunction<B, C>, mixinD: UnaryFunction<C, D>, mixinF: UnaryFunction<E, F>, mixinG: UnaryFunction<F, G>): G;
+declare function compose<T extends Constructor$1, A, B, C, D, E, F, G, H>(superclass: T, mixin: UnaryFunction<T, A>, mixinB: UnaryFunction<A, B>, mixinC: UnaryFunction<B, C>, mixinD: UnaryFunction<C, D>, mixinF: UnaryFunction<E, F>, mixinG: UnaryFunction<F, G>, mixinH: UnaryFunction<G, H>): H;
+declare function compose<T extends Constructor$1, A, B, C, D, E, F, G, H, I>(superclass: T, mixin: UnaryFunction<T, A>, mixinB: UnaryFunction<A, B>, mixinC: UnaryFunction<B, C>, mixinD: UnaryFunction<C, D>, mixinF: UnaryFunction<E, F>, mixinG: UnaryFunction<F, G>, mixinH: UnaryFunction<G, H>, mixinI: UnaryFunction<H, I>): I;
+
+/**
+ * Dynamically import a module and ensure it has a default export
+ */
+declare function importDefault<T extends object>(importFn: () => Promise<T>, filePath?: string): Promise<T extends {
+    default: infer A;
+} ? A : never>;
+
+type Constructor = new (...args: any[]) => any;
+type AbstractConstructor = abstract new (...args: any[]) => any;
+/**
+ * Define static properties on a class with inheritance in play.
+ */
+declare function defineStaticProperty<T extends Constructor | AbstractConstructor, Prop extends keyof T>(self: T, propertyName: Prop, { initialValue, strategy, }: {
+    initialValue: T[Prop];
+    strategy: 'inherit' | 'define' | ((value: T[Prop]) => T[Prop]);
+}): void;
+
+/**
+ * Extended Error object with the option to set error `status` and `code`.
+ * At AdonisJs, we prefer exceptions with proper error codes to handle
+ * them without relying on message pattern matching.
+ *
+ * ```js
+ * new Exception('message', 500, 'E_RUNTIME_EXCEPTION')
+ * ```
+ */
+declare class Exception extends Error {
+    /**
+     * Static properties to defined on the exception once
+     * and then re-use them
+     */
+    static help?: string;
+    static code?: string;
+    static status?: number;
+    static message?: string;
+    /**
+     * Name of the class that raised the exception.
+     */
+    name: string;
+    /**
+     * Optional help description for the error. You can use it to define additional
+     * human readable information for the error.
+     */
+    help?: string;
+    /**
+     * A machine readable error code. This will allow the error handling logic
+     * to narrow down exceptions based upon the error code.
+     */
+    code?: string;
+    /**
+     * A status code for the error. Usually helpful when converting errors
+     * to HTTP responses.
+     */
+    status: number;
+    constructor(message?: string, options?: ErrorOptions & {
+        code?: string;
+        status?: number;
+    });
+    get [Symbol.toStringTag](): string;
+    toString(): string;
+}
+/**
+ * Helper to create anonymous error classes
+ */
+declare function createError<T extends any[] = never>(message: string, code: string, status?: number): typeof Exception & T extends never ? {
+    new (args?: any, options?: ErrorOptions): Exception;
+} : {
+    new (args: T, options?: ErrorOptions): Exception;
+};
+
+/**
+ * Recursively flatten an object/array.
+ */
+declare function flatten<X = Record<string, any>, Y = unknown>(input: Y, glue?: string, keepNullish?: boolean): X;
+
+/**
+ * Returns an array of file paths from the given location. You can
+ * optionally filter and sort files by passing relevant options
+ *
+ * ```ts
+ * await fsReadAll(new URL('./', import.meta.url))
+ *
+ * await fsReadAll(new URL('./', import.meta.url), {
+ *   filter: (filePath) => filePath.endsWith('.js')
+ * })
+
+ * await fsReadAll(new URL('./', import.meta.url), {
+ *   absolute: true,
+ *   unixPaths: true
+ * })
+* ```
+ */
+declare function fsImportAll(location: string | URL, options?: ImportAllFilesOptions): Promise<any>;
+
+/**
+ * Returns an array of file paths from the given location. You can
+ * optionally filter and sort files by passing relevant options
+ *
+ * ```ts
+ * await fsReadAll(new URL('./', import.meta.url))
+ *
+ * await fsReadAll(new URL('./', import.meta.url), {
+ *   filter: (filePath) => filePath.endsWith('.js')
+ * })
+
+ * await fsReadAll(new URL('./', import.meta.url), {
+ *   absolute: true,
+ *   unixPaths: true
+ * })
+* ```
+ */
+declare function fsReadAll(location: string | URL, options?: ReadAllFilesOptions): Promise<string[]>;
+
+/**
+ * Returns `true` when file ends with `.js`, `.json` or
+ * `.ts` but not `.d.ts`.
+ */
+declare function isScriptFile(filePath: string): boolean;
+
+/**
+ * Message builder exposes an API to "JSON.stringify" values by
+ * encoding purpose and expiry date inside them.
+ *
+ * The return value must be further encrypted to prevent tempering.
+ */
+declare class MessageBuilder {
+    #private;
+    /**
+     * Builds a message by encoding expiry date and purpose inside it.
+     */
+    build(message: any, expiresIn?: string | number, purpose?: string): string;
+    /**
+     * Verifies the message for expiry and purpose.
+     */
+    verify<T extends any>(message: any, purpose?: string): null | T;
+}
+
+/**
+ * Perform natural sorting with "Array.sort()" method
+ */
+declare function naturalSort(current: string, next: string): number;
+
+/**
+ * A simple class to build an object incrementally. It is helpful when you
+ * want to add properties to the object conditionally.
+ *
+ * Instead of writing
+ * ```
+ * const obj = {
+ *   ...(user.id ? { id: user.id } : {}),
+ *   ...(user.firstName && user.lastName ? { name: `${user.firstName} ${user.lastName}` } : {}),
+ * }
+ * ```
+ *
+ * You can write
+ *
+ * const obj = new ObjectBuilder()
+ *   .add('id', user.id)
+ *   .add(
+ *     'fullName',
+ *     user.firstName && user.lastName ? `${user.firstName} ${user.lastName}` : undefined
+ *   )
+ *   .toObject()
+ */
+declare class ObjectBuilder<ReturnType extends Record<string, any>, IgnoreNull extends boolean = false> {
+    #private;
+    values: ReturnType;
+    constructor(initialValue: ReturnType, ignoreNull?: IgnoreNull);
+    /**
+     * Add a key-value pair to the object
+     *
+     * - Undefined values are ignored
+     * - Null values are ignored, when `ignoreNull` is set to true
+     */
+    add<Prop extends string>(key: Prop, value: undefined): this;
+    add<Prop extends string, Value>(key: Prop, value: Value): ObjectBuilder<ReturnType & {
+        [P in Prop]: Value;
+    }, IgnoreNull>;
+    /**
+     * Remove key from the object
+     */
+    remove<K extends keyof ReturnType>(key: K): this;
+    /**
+     * Find if a value exists
+     */
+    has<K extends keyof ReturnType>(key: K): boolean;
+    /**
+     * Get the existing value for a given key
+     */
+    get<K extends keyof ReturnType>(key: K): ReturnType[K];
+    /**
+     * Get the underlying constructed object
+     */
+    toObject(): IgnoreNull extends true ? {
+        [K in keyof OmitProperties<ReturnType, null>]: ReturnType[K];
+    } : {
+        [K in keyof ReturnType]: ReturnType[K];
+    };
+}
+
+type BufferSafeValue = ArrayBuffer | SharedArrayBuffer | number[] | string | {
+    valueOf(): string | object;
+} | {
+    [Symbol.toPrimitive](hint: 'string'): string;
+};
+/**
+ * Compare two values to see if they are equal. The comparison is done in
+ * a way to avoid timing-attacks.
+ */
+declare function safeEqual<T extends BufferSafeValue, U extends BufferSafeValue>(trustedValue: T, userInput: U): boolean;
+
+declare class RuntimeException extends Exception {
+    static code: string;
+    static status: number;
+}
+
+declare class InvalidArgumentsException extends Exception {
+    static code: string;
+    static status: number;
+}
+
+/**
+ * Get dirname for a given file path URL
+ */
+declare function getDirname(url: string | URL): string;
+/**
+ * Get filename for a given file path URL
+ */
+declare function getFilename(url: string | URL): string;
+
+export { Exception, InvalidArgumentsException, MessageBuilder, ObjectBuilder, RuntimeException, base64, compose, createError, defineStaticProperty, flatten, fsImportAll, fsReadAll, getDirname, getFilename, importDefault, isScriptFile, naturalSort, safeEqual };