@visulima/string 3.0.0-alpha.9 → 3.1.0

package/dist/native-string-types.d.ts

@@ -1,38 +1,277 @@
+
+/**
+ * Creates a tuple type of specified length filled with a given type.
+ * @template L - The desired length of the tuple
+ * @template T - The type to fill the tuple with (defaults to unknown)
+ * @template Result - Internal accumulator for recursive type building
+ * @returns A tuple type of length L filled with type T
+ */
 type TupleOf<L extends number, T = unknown, Result extends any[] = []> = Result["length"] extends L ? Result : TupleOf<L, T, [...Result, T]>;
+/**
+ * Internal type for implementing string slicing with both start and end indices.
+ * Handles edge cases and type safety for string literal types.
+ * @template T - The input string type
+ * @template StartIndex - The starting index for the slice
+ * @template EndIndex - The ending index for the slice
+ * @template Result - Internal accumulator for building the result string
+ */
 type InternalSliceType<T extends string, StartIndex extends number, EndIndex extends number, Result extends string = ""> = IsNumberLiteral<EndIndex | StartIndex> extends true ? T extends `${infer Head}${infer Rest}` ? IsStringLiteral<Head> extends true ? StartIndex extends 0 ? EndIndex extends 0 ? Result : InternalSliceType<Rest, 0, Math.Subtract<Math.GetPositiveIndex<T, EndIndex>, 1>, `${Result}${Head}`> : InternalSliceType<Rest, Math.Subtract<Math.GetPositiveIndex<T, StartIndex>, 1>, Math.Subtract<Math.GetPositiveIndex<T, EndIndex>, 1>, Result> : EndIndex | StartIndex extends 0 ? Result : string : IsStringLiteral<T> extends true ? Result : EndIndex | StartIndex extends 0 ? Result : string : string;
+/**
+ * Internal type for implementing string slicing with only a start index.
+ * Provides type-safe string slicing functionality for string literal types.
+ * @template T - The input string type
+ * @template StartIndex - The starting index for the slice
+ * @template Result - Internal accumulator for building the result string
+ */
 type SliceStartType<T extends string, StartIndex extends number, Result extends string = ""> = IsNumberLiteral<StartIndex> extends true ? T extends `${infer Head}${infer Rest}` ? IsStringLiteral<Head> extends true ? StartIndex extends 0 ? T : SliceStartType<Rest, Math.Subtract<Math.GetPositiveIndex<T, StartIndex>, 1>, Result> : string : IsStringLiteral<T> extends true ? Result : StartIndex extends 0 ? Result : string : string;
 type InternalEndsWithType<T extends string, S extends string, P extends number> = All<[IsStringLiteral<S>, IsNumberLiteral<P>]> extends true ? Math.IsNegative<P> extends false ? P extends Length<T> ? IsStringLiteral<T> extends true ? S extends Slice<T, Math.Subtract<Length<T>, Length<S>>, Length<T>> ? true : false : EndsWithNoPositionType<Slice<T, 0, P>, S> : EndsWithNoPositionType<Slice<T, 0, P>, S> : false : boolean;
+/**
+ * Internal type for implementing EndsWith functionality without a position parameter.
+ * Uses string reversal to check if a string ends with another string.
+ * @template T - The string to check
+ * @template S - The suffix to check for
+ */
 type EndsWithNoPositionType<T extends string, S extends string> = StartsWith<Reverse<T>, Reverse<S>>;
+/**
+ * Namespace containing type-level mathematical operations.
+ * These utilities provide type-safe arithmetic and number manipulation.
+ */
 declare namespace Math {
   type Subtract<A extends number, B extends number> = number extends A | B ? number : TupleOf<A> extends [...infer U, ...TupleOf<B>] ? U["length"] : 0;
   type IsNegative<T extends number> = number extends T ? boolean : `${T}` extends `-${number}` ? true : false;
   type Abs<T extends number> = `${T}` extends `-${infer U extends number}` ? U : T;
   type GetPositiveIndex<T extends string, I extends number> = IsNegative<I> extends false ? I : Subtract<Length<T>, Abs<I>>;
 }
+/**
+ * Type predicate that determines if a number type is a literal type rather than the general 'number' type.
+ * For example: IsNumberLiteral&lt;42> is true, but IsNumberLiteral&lt;number> is false.
+ * @template T - The number type to check
+ * @returns true if T is a number literal type, false otherwise
+ */
 type IsNumberLiteral<T extends number> = [T] extends [number] ? ([number] extends [T] ? false : true) : false;
 type IsBooleanLiteral<T extends boolean> = [T] extends [boolean] ? ([boolean] extends [T] ? false : true) : false;
+/**
+ * Type-level string reversal utility.
+ * Recursively builds the reversed string using template literal types.
+ * @template T - The string type to reverse
+ * @template Accumulator - Internal accumulator for building the reversed string
+ * @returns A type representing the reversed string
+ * @example
+ * type ReversedHello = Reverse<'hello'> // type ReversedHello = 'olleh'
+ */
 type Reverse<T extends string, Accumulator extends string = ""> = T extends `${infer Head}${infer Tail}` ? Reverse<Tail, `${Head}${Accumulator}`> : Accumulator extends "" ? T : `${T}${Accumulator}`;
+/**
+ * Type predicate that checks if all elements in a boolean array type are the literal 'true'.
+ * Distinguishes between literal true/false and the general boolean type.
+ * @template T - Array of boolean types to check
+ * @returns true if all elements are the literal true, false otherwise
+ * @example
+ * type AllTrue = All<[true, true]> // type AllTrue = true
+ * type NotAllTrue = All<[true, false]> // type NotAllTrue = false
+ */
 type All<BoolArray extends boolean[]> = IsBooleanLiteral<BoolArray[number]> extends true ? BoolArray extends [infer Head extends boolean, ...infer Rest extends boolean[]] ? Head extends true ? All<Rest> : false : true : false;
+/**
+ * Type predicate that determines if a string type is a literal type rather than the general 'string' type.
+ * @template T - The string type to check
+ * @returns true if T is a string literal type, false if it's the general string type
+ * @example
+ * type IsLiteral = IsStringLiteral<'hello'> // type IsLiteral = true
+ * type NotLiteral = IsStringLiteral<string> // type NotLiteral = false
+ */
 type IsStringLiteral<T extends string> = [T] extends [string] ? [string] extends [T] ? false : Uppercase<T> extends Uppercase<Lowercase<T>> ? Lowercase<T> extends Lowercase<Uppercase<T>> ? true : false : false : false;
 type IsStringLiteralArray<StringArray extends ReadonlyArray<string>> = IsStringLiteral<StringArray[number]> extends true ? true : false;
+/**
+ * Type-safe utility to get the character at a specific index in a string literal type.
+ * @template T - The string type to extract a character from
+ * @template Index - The numeric index of the desired character
+ * @returns The character type at the specified index, or never if the index is invalid
+ * @example
+ * type FirstChar = CharAt<'hello', 0> // type FirstChar = 'h'
+ */
 type CharAt<T extends string, Index extends number> = All<[IsStringLiteral<T>, IsNumberLiteral<Index>]> extends true ? Split<T>[Index] : string;
+/**
+ * Type-level string concatenation for tuples of string literals.
+ * Joins all strings in the tuple into a single string type.
+ * @template T - Tuple of string types to concatenate
+ * @returns A single string type representing the concatenated result
+ * @example
+ * type Combined = Concat<['hello', ' ', 'world']> // type Combined = 'hello world'
+ */
 type Concat<T extends string[]> = Join<T>;
+/**
+ * Type-level implementation of string.endsWith() functionality.
+ * Checks if a string type ends with another string type at a given position.
+ * @template T - The string type to check
+ * @template S - The suffix to check for
+ * @template P - Optional position at which to end the search
+ * @returns A boolean type indicating if T ends with S at position P
+ * @example
+ * type EndsWithWorld = EndsWith<'hello world', 'world'> // type EndsWithWorld = true
+ * type DoesNotEnd = EndsWith<'hello world', 'hello'> // type DoesNotEnd = false
+ */
 type EndsWith<T extends string, S extends string, P extends number | undefined = undefined> = P extends number ? InternalEndsWithType<T, S, P> : EndsWithNoPositionType<T, S>;
+/**
+ * Type-level implementation of string.includes() functionality.
+ * Determines if one string type contains another string type starting at an optional position.
+ * @template T - The string type to search within
+ * @template S - The string type to search for
+ * @template P - Optional position to start the search from
+ * @returns A boolean type indicating if S is found within T starting at P
+ * @example
+ * type HasWorld = Includes<'hello world', 'world'> // type HasWorld = true
+ * type NoWorld = Includes<'hello', 'world'> // type NoWorld = false
+ */
 type Includes<T extends string, S extends string, P extends number = 0> = string extends S | T ? boolean : Math.IsNegative<P> extends false ? P extends 0 ? T extends `${string}${S}${string}` ? true : false : Includes<Slice<T, P>, S> : Includes<T, S>;
+/**
+ * Type-level implementation of Array.join() functionality for string tuples.
+ * Combines string literal types in a tuple using a delimiter.
+ * @template T - Tuple of string types to join
+ * @template Delimiter - The delimiter to insert between elements
+ * @returns A string type representing the joined result
+ * @example
+ * type Joined = Join<['a', 'b', 'c'], '.'> // type Joined = 'a.b.c'
+ */
 type Join<T extends ReadonlyArray<string>, Delimiter extends string = ""> = All<[IsStringLiteralArray<T>, IsStringLiteral<Delimiter>]> extends true ? T extends readonly [infer First extends string, ...infer Rest extends string[]] ? Rest extends [] ? First : `${First}${Delimiter}${Join<Rest, Delimiter>}` : "" : string;
+/**
+ * Type-level utility to compute the length of a string literal type.
+ * @template T - The string type to measure
+ * @returns A number literal type representing the string's length
+ * @example
+ * type Len = Length<'hello'> // type Len = 5
+ */
 type Length<T extends string> = IsStringLiteral<T> extends true ? Split<T>["length"] : number;
-type PadEnd<T extends string, Times extends number = 0, Pad extends string = " "> = All<[IsStringLiteral<Pad | T>, IsNumberLiteral<Times>]> extends true ? Math.IsNegative<Times> extends false ? Math.Subtract<Times, Length<T>> extends infer Missing extends number ? `${T}${Slice<Repeat<Pad, Missing>, 0, Missing>}` : never : T : string;
-type PadStart<T extends string, Times extends number = 0, Pad extends string = " "> = All<[IsStringLiteral<Pad | T>, IsNumberLiteral<Times>]> extends true ? Math.IsNegative<Times> extends false ? Math.Subtract<Times, Length<T>> extends infer Missing extends number ? `${Slice<Repeat<Pad, Missing>, 0, Missing>}${T}` : never : T : string;
+/**
+ * Type-level implementation of string.padEnd() functionality.
+ * Adds padding to the end of a string type until it reaches a specified length.
+ * @template T - The string type to pad
+ * @template Times - Target total length of the padded string
+ * @template Pad - The string to use as padding (defaults to space)
+ * @returns A string type with the padding added to the end
+ * @example
+ * type Padded = PadEnd<'hello', 7, '_'> // type Padded = 'hello__'
+ */
+type PadEnd<T extends string, Times extends number = 0, Pad extends string = " "> = All<[IsStringLiteral<Pad | T>, IsNumberLiteral<Times>]> extends true ? Math.IsNegative<Times> extends false ? Math.Subtract<Times, Length<T>> extends (infer Missing extends number) ? `${T}${Slice<Repeat<Pad, Missing>, 0, Missing>}` : never : T : string;
+/**
+ * Type-level implementation of string.padStart() functionality.
+ * Adds padding to the beginning of a string type until it reaches a specified length.
+ * @template T - The string type to pad
+ * @template Times - Target total length of the padded string
+ * @template Pad - The string to use as padding (defaults to space)
+ * @returns A string type with the padding added to the start
+ * @example
+ * type Padded = PadStart<'hello', 7, '_'> // type Padded = '__hello'
+ */
+type PadStart<T extends string, Times extends number = 0, Pad extends string = " "> = All<[IsStringLiteral<Pad | T>, IsNumberLiteral<Times>]> extends true ? Math.IsNegative<Times> extends false ? Math.Subtract<Times, Length<T>> extends (infer Missing extends number) ? `${Slice<Repeat<Pad, Missing>, 0, Missing>}${T}` : never : T : string;
+/**
+ * Type-level implementation of string.repeat() functionality.
+ * Creates a new string type by repeating the input string a specified number of times.
+ * @template T - The string type to repeat
+ * @template Times - The number of times to repeat the string
+ * @returns A string type containing T repeated Times times
+ * @example
+ * type Repeated = Repeat<'abc', 2> // type Repeated = 'abcabc'
+ */
 type Repeat<T extends string, Times extends number = 0> = All<[IsStringLiteral<T>, IsNumberLiteral<Times>]> extends true ? Times extends 0 ? "" : Math.IsNegative<Times> extends false ? Join<TupleOf<Times, T>> : never : string;
+/**
+ * Type-level implementation of string.replaceAll() functionality.
+ * Replaces all occurrences of a substring with another string.
+ * @template Sentence - The string type to perform replacements on
+ * @template Lookup - The string or RegExp pattern to search for. When a RegExp is used, the result type widens to string.
+ * @template Replacement - The string type to replace matches with
+ * @returns A string type with all occurrences of Lookup replaced with Replacement. When Lookup is a RegExp, returns string.
+ * @example
+ * type Replaced = ReplaceAll<'hello hello', 'hello', 'hi'> // type Replaced = 'hi hi'
+ */
 type ReplaceAll<Sentence extends string, Lookup extends RegExp | string, Replacement extends string = ""> = Lookup extends string ? IsStringLiteral<Lookup | Replacement | Sentence> extends true ? Sentence extends `${infer Rest}${Lookup}${infer Rest2}` ? `${Rest}${Replacement}${ReplaceAll<Rest2, Lookup, Replacement>}` : Sentence : string : string;
+/**
+ * Type-level implementation of string.replace() functionality.
+ * Replaces the first occurrence of a substring with another string.
+ * @template Sentence - The string type to perform replacement on
+ * @template Lookup - The string or RegExp pattern to search for. When a RegExp is used, the result type widens to string.
+ * @template Replacement - The string type to replace the match with
+ * @returns A string type with the first occurrence of Lookup replaced with Replacement. When Lookup is a RegExp, returns string.
+ * @example
+ * type Replaced = Replace<'hello hello', 'hello', 'hi'> // type Replaced = 'hi hello'
+ */
 type Replace<Sentence extends string, Lookup extends RegExp | string, Replacement extends string = ""> = Lookup extends string ? IsStringLiteral<Lookup | Replacement | Sentence> extends true ? Sentence extends `${infer Rest}${Lookup}${infer Rest2}` ? `${Rest}${Replacement}${Rest2}` : Sentence : string : string;
+/**
+ * Type-level implementation of string.slice() functionality.
+ * Extracts a portion of a string type between start and end indices.
+ * @template T - The string type to slice
+ * @template StartIndex - The starting index of the slice
+ * @template EndIndex - The ending index of the slice (optional)
+ * @returns A string type containing the characters between the indices
+ * @example
+ * type Sliced = Slice<'hello world', 0, 5> // type Sliced = 'hello'
+ * type ToEnd = Slice<'hello world', 6> // type ToEnd = 'world'
+ */
 type Slice<T extends string, StartIndex extends number = 0, EndIndex extends number | undefined = undefined> = EndIndex extends number ? InternalSliceType<T, StartIndex, EndIndex> : SliceStartType<T, StartIndex>;
+/**
+ * Type-level implementation of string.split() functionality.
+ * Splits a string type into a tuple of string types based on a delimiter.
+ * @template T - The string type to split
+ * @template Delimiter - The string type to use as a separator
+ * @returns A tuple type containing the split string parts
+ * @example
+ * type Parts = Split<'a,b,c', ','> // type Parts = ['a', 'b', 'c']
+ */
 type Split<T extends string, Delimiter extends string = ""> = IsStringLiteral<Delimiter | T> extends true ? T extends `${infer First}${Delimiter}${infer Rest}` ? [First, ...Split<Rest, Delimiter>] : T extends "" ? [] : [T] : string[];
+/**
+ * Type-level implementation of string.startsWith() functionality.
+ * Checks if a string type begins with another string type at a given position.
+ * @template T - The string type to check
+ * @template S - The prefix to check for
+ * @template P - Optional position at which to start the search
+ * @returns A boolean type indicating if T starts with S at position P
+ * @example
+ * type StartsWithHello = StartsWith<'hello world', 'hello'> // type StartsWithHello = true
+ * type DoesNotStart = StartsWith<'hello world', 'world'> // type DoesNotStart = false
+ */
 type StartsWith<T extends string, S extends string, P extends number = 0> = All<[IsStringLiteral<S>, IsNumberLiteral<P>]> extends true ? Math.IsNegative<P> extends false ? P extends 0 ? S extends `${infer SHead}${infer SRest}` ? T extends `${infer THead}${infer TRest}` ? IsStringLiteral<SHead | THead> extends true ? THead extends SHead ? StartsWith<TRest, SRest> : false : boolean : IsStringLiteral<T> extends true ? false : boolean : true : StartsWith<Slice<T, P>, S> : StartsWith<T, S> : boolean;
+/**
+ * Type-level implementation of string.trimEnd() functionality.
+ * Removes whitespace characters from the end of a string type.
+ * @template T - The string type to trim
+ * @returns A string type with trailing whitespace removed
+ * @example
+ * type Trimmed = TrimEnd<'hello  '> // type Trimmed = 'hello'
+ */
 type TrimEnd<T extends string> = T extends `${infer Rest} ` ? TrimEnd<Rest> : T;
+/**
+ * Type-level implementation of string.trimStart() functionality.
+ * Removes whitespace characters from the beginning of a string type.
+ * @template T - The string type to trim
+ * @returns A string type with leading whitespace removed
+ * @example
+ * type Trimmed = TrimStart<'  hello'> // type Trimmed = 'hello'
+ */
 type TrimStart<T extends string> = T extends ` ${infer Rest}` ? TrimStart<Rest> : T;
+/**
+ * Type-level implementation of string.trim() functionality.
+ * Removes whitespace characters from both ends of a string type.
+ * @template T - The string type to trim
+ * @returns A string type with both leading and trailing whitespace removed
+ * @example
+ * type Trimmed = Trim<'  hello  '> // type Trimmed = 'hello'
+ */
 type Trim<T extends string> = TrimEnd<TrimStart<T>>;
+/**
+ * Type-level implementation of string.toLowerCase() functionality.
+ * Converts all alphabetic characters in a string type to lowercase.
+ * @template T - The string type to convert
+ * @returns A string type with all characters converted to lowercase
+ * @example
+ * type Lower = ToLowerCase<'HELLO'> // type Lower = 'hello'
+ */
 type ToLowerCase<T extends string> = IsStringLiteral<T> extends true ? Lowercase<T> : string;
+/**
+ * Type-level implementation of string.toUpperCase() functionality.
+ * Converts all alphabetic characters in a string type to uppercase.
+ * @template T - The string type to convert
+ * @returns A string type with all characters converted to uppercase
+ * @example
+ * type Upper = ToUpperCase<'hello'> // type Upper = 'HELLO'
+ */
 type ToUpperCase<T extends string> = IsStringLiteral<T> extends true ? Uppercase<T> : string;
 declare global {
   interface String {
@@ -41,20 +280,17 @@ declare global {
      * @param index The zero-based index of the desired character.
      */
     charAt<T extends string = string, I extends number = number>(this: T, index: I): CharAt<T, I>;
-
     /**
      * Returns a string that contains the concatenation of two or more strings.
      * @param strings The strings to append to the end of the string.
      */
     concat<T extends string = string, S extends string[] | string = string>(this: T, ...strings: S extends string ? [S] : S extends string[] ? S : never): S extends string ? Concat<[T, S]> : S extends string[] ? Concat<[T, ...S]> : never;
-
     /**
      * Returns true if the sequence of elements of searchString converted to a String is the
      * same as the corresponding elements of this object (converted to a String) starting at
      * position. Otherwise returns false.
      */
     endsWith<T extends string = string, S extends string = string, P extends number | undefined = undefined>(this: T, searchString: S, position?: P): EndsWith<T, S, P>;
-
     /**
      * Returns true if searchString appears as a substring of the result of converting this
      * object to a String, at one or more positions that are greater than or equal to
@@ -63,12 +299,10 @@ declare global {
      * @param position If position is undefined, 0 is assumed, so as to search all of the String.
      */
     includes<T extends string = string, S extends string = string, P extends number = 0>(this: T, searchString: S, position?: P): Includes<T, S, P>;
-
     /**
      * Returns the length of a String object.
      */
     length: Length<this>;
-
     /**
      * Pads the current string with a given string (possibly repeated) so that the resulting string reaches a given length.
      * The padding is applied from the end (right) of the current string.
@@ -76,7 +310,6 @@ declare global {
      * @param fillString The string to pad the current string with. If this string is too long, it will be truncated and the left-most part will be applied.
      */
     padEnd<T extends string = string, N extends number = number, P extends string = " ">(this: T, maxLength: N, fillString?: P): PadEnd<T, N, P>;
-
     /**
      * Pads the current string with a given string (possibly repeated) so that the resulting string reaches a given length.
      * The padding is applied from the start (left) of the current string.
@@ -84,61 +317,51 @@ declare global {
      * @param fillString The string to pad the current string with. If this string is too long, it will be truncated and the left-most part will be applied.
      */
     padStart<T extends string = string, N extends number = number, P extends string = " ">(this: T, maxLength: N, fillString?: P): PadStart<T, N, P>;
-
     /**
      * Replace text in a string, using a regular expression or search string.
      * @param searchValue A string to search for.
      * @param replaceValue A string containing the text to replace for every successful match of searchValue in this string.
      */
     replace<T extends string = string, S extends RegExp | string = string, R extends string = string>(this: T, searchValue: S, replaceValue: R): Replace<T, S, R>;
-
     /**
      * Replace all instances of a substring in a string, using a regular expression or search string.
      * @param searchValue A string to search for.
      * @param replaceValue A string containing the text to replace for every successful match of searchValue in this string.
      */
     replaceAll<T extends string = string, S extends RegExp | string = string, R extends string = string>(this: T, searchValue: S, replaceValue: R): ReplaceAll<T, S, R>;
-
     /**
      * Returns a section of a string.
      * @param start The index to the beginning of the specified portion of stringObj.
      * @param end The index to the end of the specified portion of stringObj. The substring includes the characters up to, but not including, the character indicated by end.
      */
     slice<T extends string = string, S extends number = number, E extends number | undefined = undefined>(this: T, start?: S, end?: E): Slice<T, S, E>;
-
     /**
      * Split a string into substrings using the specified separator and return them as an array.
      * @param separator A string that identifies character or characters to use in separating the string. If omitted, a single-element array containing the entire string is returned.
      */
     split<T extends string = string, S extends string = string>(this: T, separator: S): Split<T, S>;
-
     /**
      * Returns true if the sequence of elements of searchString converted to a String is the
      * same as the corresponding elements of this object (converted to a String) starting at
      * position. Otherwise returns false.
      */
     startsWith<T extends string = string, S extends string = string, P extends number = 0>(this: T, searchString: S, position?: P): StartsWith<T, S, P>;
-
     /**
      * Converts all alphabetic characters in a string to lowercase.
      */
     toLowerCase<T extends string = string>(this: T): ToLowerCase<T>;
-
     /**
      * Converts all alphabetic characters in a string to uppercase.
      */
     toUpperCase<T extends string = string>(this: T): ToUpperCase<T>;
-
     /**
      * Returns a string with all whitespace removed from both ends of a string.
      */
     trim<T extends string = string>(this: T): Trim<T>;
-
     /**
      * Returns a string with all whitespace removed from the end of a string.
      */
     trimEnd<T extends string = string>(this: T): TrimEnd<T>;
-
     /**
      * Returns a string with all whitespace removed from the start of a string.
      */

package/dist/outdent.d.ts

@@ -1,14 +1,88 @@
 declare const outdent: Outdent;
+/**
+ * Represents the outdent function, which can be called as a template tag
+ * or as a function to create a new instance with specific options.
+ * It also includes a `.string()` method for processing regular strings.
+ */
 interface Outdent {
+  /**
+   * Remove indentation from a template literal.
+   * Tag function for template literals.
+   * @param strings The static string parts of the template literal.
+   * @param values The interpolated values.
+   * @returns The processed string with indentation removed.
+   */
   (strings: TemplateStringsArray, ...values: any[]): string;
+  /**
+   * Create and return a new Outdent instance with the given options.
+   * @param options Configuration options for the new instance.
+   * @returns A new Outdent function instance.
+   */
   (options: Options): Outdent;
+  /**
+   * Remove indentation from a string
+   * @param string_ The raw string to process.
+   * @returns The processed string with indentation removed.
+   */
   string: (string_: string) => string;
 }
+/**
+ * Configuration options for the outdent function.
+ */
 interface Options {
+  /**
+   * Whether to cache processed template literals for better performance when
+   * using the same template multiple times.
+   *
+   * Enabling caching can significantly improve performance when the same template
+   * is used repeatedly, such as in loops or frequently called functions.
+   * @example
+   * // Create an outdent function with caching enabled (default)
+   * const dedent = outdent();
+   *
+   * // Create an outdent function with caching disabled
+   * const noCacheDedent = outdent({ cache: false });
+   * @default true
+   */
   cache?: boolean;
+  /**
+   * Custom cache store to use instead of the default WeakMap.
+   * Must be a WeakMap instance.
+   *
+   * This allows you to provide your own WeakMap instance for caching,
+   * which can be useful for advanced use cases or for sharing cache
+   * between multiple outdent instances.
+   * @example
+   * // Create a custom cache
+   * const customCache = new WeakMap();
+   *
+   * // Create an outdent function with a custom cache
+   * const customCacheDedent = outdent({ cacheStore: customCache });
+   */
   cacheStore?: WeakMap<TemplateStringsArray, string[]>;
+  /**
+   * Normalize all newlines in the template literal to this value.
+   *
+   * If `null`, newlines are left untouched.
+   *
+   * Newlines that get normalized are '\r\n', '\r', and '\n'.
+   *
+   * Newlines within interpolated values are *never* normalized.
+   *
+   * Although intended for normalizing to '\n' or '\r\n',
+   * you can also set to any string; for example ' '.
+   * @default null
+   */
   newline?: string | null;
+  /**
+   * Whether to trim the leading newline in the template literal.
+   * @default true
+   */
   trimLeadingNewline?: boolean;
+  /**
+   * Whether to trim the trailing newline in the template literal.
+   * @default true
+   */
   trimTrailingNewline?: boolean;
 }
 export { Options, Outdent, outdent };

package/dist/outdent.js

@@ -1,109 +1 @@
-import { a as RE_LEADING_NEWLINE, b as RE_TRAILING_NEWLINE, c as RE_ONLY_WHITESPACE_WITH_AT_LEAST_ONE_NEWLINE, d as RE_STARTS_WITH_NEWLINE_OR_IS_EMPTY, e as RE_MATCH_NEWLINES, f as RE_DETECT_INDENTATION } from './packem_shared/constants-BsZS5f0z.js';
-
-const has = (object, property) => Object.hasOwn(object, property);
-const extend = (target, source) => Object.assign(target, source);
-const internalOutdentArray = (strings, firstInterpolatedValueSetsIndentationLevel, options) => {
-  if (strings.length === 0) {
-    return [];
-  }
-  let indentationLevel = 0;
-  const match = RE_DETECT_INDENTATION.exec(strings[0]);
-  if (match) {
-    indentationLevel = match[1].length;
-  }
-  const reSource = String.raw`(\r\n|\r|\n).{0,${indentationLevel}}`;
-  const reMatchIndent = new RegExp(reSource, "g");
-  const processedStrings = firstInterpolatedValueSetsIndentationLevel ? strings.slice(1) : strings;
-  const { newline, trimLeadingNewline, trimTrailingNewline } = options;
-  const normalizeNewlines = typeof newline === "string";
-  const l = processedStrings.length;
-  const outdentedStrings = Array.from({ length: l });
-  for (let index = 0; index < l; index++) {
-    let v = processedStrings[index];
-    v = v.replace(reMatchIndent, "$1");
-    if (index === 0 && trimLeadingNewline) {
-      v = v.replace(RE_LEADING_NEWLINE, "");
-    }
-    if (index === l - 1 && trimTrailingNewline) {
-      v = v.replace(RE_TRAILING_NEWLINE, "");
-    }
-    if (normalizeNewlines) {
-      v = v.replaceAll(RE_MATCH_NEWLINES, newline);
-    }
-    outdentedStrings[index] = v;
-  }
-  return outdentedStrings;
-};
-const concatStringsAndValues = (strings, values) => {
-  const chunks = Array.from({ length: strings.length + values.length });
-  let index = 0;
-  const l = strings.length;
-  for (; index < l - 1; index++) {
-    chunks[index * 2] = strings[index];
-    chunks[index * 2 + 1] = String(values[index]);
-  }
-  chunks[index * 2] = strings[index];
-  return chunks.join("");
-};
-const isTemplateStringsArray = (v) => has(v, "raw") && has(v, "length");
-const templateCache = /* @__PURE__ */ new WeakMap();
-const createInstance = (options) => {
-  const enableCache = options.cache !== false;
-  const cache = enableCache ? options.cacheStore ?? templateCache : void 0;
-  const hasNewlineOption = options.newline !== void 0;
-  function outdent2(stringsOrOptions, ...values) {
-    if (isTemplateStringsArray(stringsOrOptions)) {
-      const strings = stringsOrOptions;
-      const valuesLength = values.length;
-      if (strings.length === 1 && strings[0] === "") {
-        return "";
-      }
-      if (valuesLength === 0) {
-        if (enableCache && cache && !hasNewlineOption) {
-          const cached = cache.get(strings);
-          if (cached) {
-            return cached[0];
-          }
-        }
-        const result = internalOutdentArray(strings, false, options);
-        if (enableCache && cache) {
-          cache.set(strings, result);
-        }
-        return result[0];
-      }
-      const firstValueIsOutdent = values[0] === outdent2 || values[0] === defaultOutdent;
-      const firstInterpolatedValueSetsIndentationLevel = firstValueIsOutdent && RE_ONLY_WHITESPACE_WITH_AT_LEAST_ONE_NEWLINE.test(strings[0]) && RE_STARTS_WITH_NEWLINE_OR_IS_EMPTY.test(strings[1]);
-      let renderedArray;
-      if (enableCache && cache && !hasNewlineOption) {
-        renderedArray = cache.get(strings);
-      }
-      if (!renderedArray) {
-        renderedArray = internalOutdentArray(strings, firstInterpolatedValueSetsIndentationLevel, options);
-        if (enableCache && cache) {
-          cache.set(strings, renderedArray);
-        }
-      }
-      return concatStringsAndValues(renderedArray, firstInterpolatedValueSetsIndentationLevel ? values.slice(1) : values);
-    }
-    return createInstance(extend(extend({}, options), stringsOrOptions));
-  }
-  return extend(outdent2, {
-    string(string_) {
-      if (string_ === "" || !string_) {
-        return "";
-      }
-      return internalOutdentArray([string_], false, options)[0];
-    }
-  });
-};
-const defaultOutdent = createInstance({
-  cache: true,
-  // Enable caching by default
-  // eslint-disable-next-line unicorn/no-null
-  newline: null,
-  trimLeadingNewline: true,
-  trimTrailingNewline: true
-});
-const outdent = defaultOutdent;
-
-export { outdent };
+import{f as A,g as R,h as p,i as S,j as W,k as m}from"./packem_shared/constants-aPzGW29R.js";const I=(e,r)=>Object.hasOwn(e,r),T=(e,r)=>Object.assign(e,r),h=(e,r,n)=>{if(e.length===0)return[];let t=0;const s=m.exec(e[0]);s&&(t=s[1].length);const i=String.raw`(\r\n|\r|\n).{0,${t}}`,g=new RegExp(i,"g"),l=r?e.slice(1):e,{newline:N,trimLeadingNewline:_,trimTrailingNewline:o}=n,f=typeof N=="string",E=l.length,u=Array.from({length:E});for(let c=0;c<E;c++){let a=l[c];a=a.replace(g,"$1"),c===0&&_&&(a=a.replace(A,"")),c===E-1&&o&&(a=a.replace(R,"")),f&&(a=a.replaceAll(W,N)),u[c]=a}return u},O=(e,r)=>{const n=Array.from({length:e.length+r.length});let t=0;const s=e.length;for(;t<s-1;t++)n[t*2]=e[t],n[t*2+1]=String(r[t]);return n[t*2]=e[t],n.join("")},d=e=>I(e,"raw")&&I(e,"length"),j=new WeakMap,w=e=>{const r=e.cache!==!1,n=r?e.cacheStore??j:void 0,t=e.newline!==void 0;function s(i,...g){if(d(i)){const l=i,N=g.length;if(l.length===1&&l[0]==="")return"";if(N===0){if(r&&n&&!t){const E=n.get(l);if(E)return E[0]}const f=h(l,!1,e);return r&&n&&n.set(l,f),f[0]}const _=(g[0]===s||g[0]===L)&&p.test(l[0])&&S.test(l[1]);let o;return r&&n&&!t&&(o=n.get(l)),o||(o=h(l,_,e),r&&n&&n.set(l,o)),O(o,_?g.slice(1):g)}return w(T(T({},e),i))}return T(s,{string(i){return i===""||!i?"":h([i],!1,e)[0]}})},L=w({cache:!0,newline:null,trimLeadingNewline:!0,trimTrailingNewline:!0}),b=L;export{b as outdent};

package/dist/packem_shared/_isFullWidth-Dqc3MWgl.js

@@ -0,0 +1 @@
+const r=[161,161,164,164,167,168,170,170,173,174,176,180,182,186,188,191,198,198,208,208,215,216,222,225,230,230,232,234,236,237,240,240,242,243,247,250,252,252,254,254,257,257,273,273,275,275,283,283,294,295,299,299,305,307,312,312,319,322,324,324,328,331,333,333,338,339,358,359,363,363,462,462,464,464,466,466,468,468,470,470,472,472,474,474,476,476,593,593,609,609,708,708,711,711,713,715,717,717,720,720,728,731,733,733,735,735,768,879,913,929,931,937,945,961,963,969,1025,1025,1040,1103,1105,1105,8208,8208,8211,8214,8216,8217,8220,8221,8224,8226,8228,8231,8240,8240,8242,8243,8245,8245,8251,8251,8254,8254,8308,8308,8319,8319,8321,8324,8364,8364,8451,8451,8453,8453,8457,8457,8467,8467,8470,8470,8481,8482,8486,8486,8491,8491,8531,8532,8539,8542,8544,8555,8560,8569,8585,8585,8592,8601,8632,8633,8658,8658,8660,8660,8679,8679,8704,8704,8706,8707,8711,8712,8715,8715,8719,8719,8721,8721,8725,8725,8730,8730,8733,8736,8739,8739,8741,8741,8743,8748,8750,8750,8756,8759,8764,8765,8776,8776,8780,8780,8786,8786,8800,8801,8804,8807,8810,8811,8814,8815,8834,8835,8838,8839,8853,8853,8857,8857,8869,8869,8895,8895,8978,8978,9312,9449,9451,9547,9552,9587,9600,9615,9618,9621,9632,9633,9635,9641,9650,9651,9654,9655,9660,9661,9664,9665,9670,9672,9675,9675,9678,9681,9698,9701,9711,9711,9733,9734,9737,9737,9742,9743,9756,9756,9758,9758,9792,9792,9794,9794,9824,9825,9827,9829,9831,9834,9836,9837,9839,9839,9886,9887,9919,9919,9926,9933,9935,9939,9941,9953,9955,9955,9960,9961,9963,9969,9972,9972,9974,9977,9979,9980,9982,9983,10045,10045,10102,10111,11094,11097,12872,12879,57344,63743,65024,65039,65533,65533,127232,127242,127248,127277,127280,127337,127344,127373,127375,127376,127387,127404,917760,917999,983040,1048573,1048576,1114109],d=12288,m=65510,f=[12288,12288,65281,65376,65504,65510],g=8361,h=65518,w=[8361,8361,65377,65470,65474,65479,65482,65487,65490,65495,65498,65500,65512,65518],M=32,C=10630,P=[32,126,162,163,165,166,172,172,175,175,10214,10221,10629,10630],c=4352,b=262141,t=[4352,4447,8986,8987,9001,9002,9193,9196,9200,9200,9203,9203,9725,9726,9748,9749,9776,9783,9800,9811,9855,9855,9866,9871,9875,9875,9889,9889,9898,9899,9917,9918,9924,9925,9934,9934,9940,9940,9962,9962,9970,9971,9973,9973,9978,9978,9981,9981,9989,9989,9994,9995,10024,10024,10060,10060,10062,10062,10067,10069,10071,10071,10133,10135,10160,10160,10175,10175,11035,11036,11088,11088,11093,11093,11904,11929,11931,12019,12032,12245,12272,12287,12289,12350,12353,12438,12441,12543,12549,12591,12593,12686,12688,12773,12783,12830,12832,12871,12880,42124,42128,42182,43360,43388,44032,55203,63744,64255,65040,65049,65072,65106,65108,65126,65128,65131,94176,94180,94192,94198,94208,101589,101631,101662,101760,101874,110576,110579,110581,110587,110589,110590,110592,110882,110898,110898,110928,110930,110933,110933,110948,110951,110960,111355,119552,119638,119648,119670,126980,126980,127183,127183,127374,127374,127377,127386,127488,127490,127504,127547,127552,127560,127568,127569,127584,127589,127744,127776,127789,127797,127799,127868,127870,127891,127904,127946,127951,127955,127968,127984,127988,127988,127992,128062,128064,128064,128066,128252,128255,128317,128331,128334,128336,128359,128378,128378,128405,128406,128420,128420,128507,128591,128640,128709,128716,128716,128720,128722,128725,128728,128732,128735,128747,128748,128756,128764,128992,129003,129008,129008,129292,129338,129340,129349,129351,129535,129648,129660,129664,129674,129678,129734,129736,129736,129741,129756,129759,129770,129775,129784,131072,196605,196608,262141],u=(i,l)=>{let e=0,o=Math.floor(i.length/2)-1;for(;e<=o;){const n=Math.floor((e+o)/2),a=n*2;if(l<i[a])o=n-1;else if(l>i[a+1])e=n+1;else return!0}return!1},s=19968,[x,R]=W(t);function W(i){let l=i[0],e=i[1];for(let o=0;o<i.length;o+=2){const n=i[o],a=i[o+1];if(s>=n&&s<=a)return[n,a];a-n>e-l&&(l=n,e=a)}return[l,e]}const j=i=>i<161||i>1114109?!1:u(r,i),k=i=>i<d||i>m?!1:u(f,i),p=i=>i<g||i>h?!1:u(w,i),y=i=>i<M||i>C?!1:u(P,i),A=i=>i>=x&&i<=R?!0:i<c||i>b?!1:u(t,i);function E(i){return j(i)?"ambiguous":k(i)?"fullwidth":p(i)?"halfwidth":y(i)?"narrow":A(i)?"wide":"neutral"}export{E as getCategory,j as isAmbiguous,k as isFullWidth,A as isWide};

package/dist/packem_shared/closest-C6YDQs4m.js

@@ -0,0 +1 @@
+const i=new Uint32Array(65536),q=(r,l)=>{const o=r.length,n=l.length,a=1<<o-1;let c=-1,d=0,p=o,h=o;for(;h--;)i[r.charCodeAt(h)]|=1<<h;for(h=0;h<n;h++){let A=i[l.charCodeAt(h)];const g=A|d;A|=(A&c)+c^c,d|=~(A|c),c&=A,d&a&&p++,c&a&&p--,d=d<<1|1,c=c<<1|~(g|d),d&=g}for(h=o;h--;)i[r.charCodeAt(h)]=0;return p},z=(r,l)=>{const o=l.length,n=r.length,a=[],c=[],d=Math.ceil(o/32),p=Math.ceil(n/32);for(let t=0;t<d;t++)c[t]=-1,a[t]=0;let h=0;for(;h<p-1;h++){let t=0,s=-1;const M=h*32,u=Math.min(32,n)+M;for(let e=M;e<u;e++)i[r.charCodeAt(e)]|=1<<e;for(let e=0;e<o;e++){const m=i[l.charCodeAt(e)],C=c[e/32|0]>>>e&1,f=a[e/32|0]>>>e&1,j=m|t,k=((m|f)&s)+s^s|m|f;let x=t|~(k|s),w=s&k;x>>>31^C&&(c[e/32|0]^=1<<e),w>>>31^f&&(a[e/32|0]^=1<<e),x=x<<1|C,w=w<<1|f,s=w|~(j|x),t=x&j}for(let e=M;e<u;e++)i[r.charCodeAt(e)]=0}let A=0,g=-1;const v=h*32,U=Math.min(32,n-v)+v;for(let t=v;t<U;t++)i[r.charCodeAt(t)]|=1<<t;let y=n;for(let t=0;t<o;t++){const s=i[l.charCodeAt(t)],M=c[t/32|0]>>>t&1,u=a[t/32|0]>>>t&1,e=s|A,m=((s|u)&g)+g^g|s|u;let C=A|~(m|g),f=g&m;y+=C>>>n-1&1,y-=f>>>n-1&1,C>>>31^M&&(c[t/32|0]^=1<<t),f>>>31^u&&(a[t/32|0]^=1<<t),C=C<<1|M,f=f<<1|u,g=f|~(e|C),A=C&e}for(let t=v;t<U;t++)i[r.charCodeAt(t)]=0;return y},I=(r,l)=>{if(r.length<l.length){const o=l;l=r,r=o}return l.length===0?r.length:r.length<=32?q(r,l):z(r,l)},_=(r,l)=>{let o=1/0,n=0;for(let a=0;a<l.length;a++){const c=I(r,l[a]);c<o&&(o=c,n=a)}return l[n]};export{_ as closest,I as distance};

package/dist/packem_shared/constants-aPzGW29R.js

@@ -0,0 +1 @@
+const R=String.raw,E=R`\p{Emoji}(?:\p{EMod}|[\u{E0020}-\u{E007E}]+\u{E007F}|\uFE0F?\u20E3?)`,a=()=>new RegExp(R`\p{RI}{2}|(?![#*\d](?!\uFE0F?\u20E3))${E}(?:\u200D${E})*`,"gu"),n=new Set(["\x1B","›"]),e="\x07",_="[",r="m",u="]8;;",S=39,s=/[\u200B\uFEFF\u2060-\u2064]/g,I=new RegExp(`(?:\\${_}(?<code>\\d+)m|\\${u}(?<uri>.*)${e})`),i=Object.freeze(new Map([[0,0],[1,22],[2,22],[3,23],[4,24],[7,27],[8,28],[9,29],[30,39],[31,39],[32,39],[33,39],[34,39],[35,39],[36,39],[37,39],[40,49],[41,49],[42,49],[43,49],[44,49],[45,49],[46,49],[47,49],[90,39]])),t=/^[ \t]*(?:\r\n|\r|\n)/,N=/(?:\r\n|\r|\n)[ \t]*$/,g=/^(?:[\r\n]|$)/,c=/(?:\r\n|\r|\n)([ \t]*)(?:[^ \t\r\n]|$)/,T=/^[ \t]*[\r\n][ \t\r\n]*$/,L=/\r\n|\n|\r/g,w=/[\u001B\u009B](?:[[()#;?]{0,10}(?:\d{1,4}(?:;\d{0,4})*)?[0-9A-ORZcf-nqry=><]|\]8;;[^\u0007\u001B]{0,100}(?:\u0007|\u001B\\))/g,x=/\u001B\[[\d;]*m[^\u001B]*(?:\u001B\[[\d;]*m|$)/g,B=/\u001B\]8;[^\u0007\u001B]*(?:\u0007|\u001B\\)[^\u001B]*\u001B\]8;;(?:\u0007|\u001B\\)/g,O=/[\u0000-\u0008\n-\u001F\u007F-\u009F]{1,1000}/y,A=a(),H=/[-_./\s]+/g,C=/(\u001B\[[0-9;]*[a-z])/i,G=new RegExp("\\p{Script=Arabic}","u"),M=new RegExp("\\p{Script=Bengali}","u"),D=new RegExp("\\p{Script=Cyrillic}","u"),K=new RegExp("\\p{Script=Devanagari}","u"),F=new RegExp("\\p{Script=Ethiopic}","u"),P=new RegExp("\\p{Script=Greek}","u"),m=new RegExp("\\p{Script=Greek}+|\\p{Script=Latin}+|[^\\p{Script=Greek}\\p{Script=Latin}]+","gu"),l=new RegExp("\\p{Script=Gujarati}","u"),o=new RegExp("\\p{Script=Gurmukhi}","u"),W=new RegExp("\\p{Script=Hangul}","u"),d=new RegExp("\\p{Script=Hebrew}","u"),$=new RegExp("\\p{Script=Hiragana}","u"),U=new RegExp("\\p{Script=Han}","u"),y=new RegExp("\\p{Script=Kannada}","u"),Y=new RegExp("\\p{Script=Katakana}","u"),h=new RegExp("\\p{Script=Khmer}","u"),k=new RegExp("\\p{Script=Lao}","u"),b=new RegExp("\\p{Script=Latin}","u"),j=new RegExp("\\p{Script=Malayalam}","u"),J=new RegExp("\\p{Script=Myanmar}","u"),V=new RegExp("\\p{Script=Oriya}","u"),f=new RegExp("\\p{Script=Sinhala}","u"),z=new RegExp("\\p{Script=Tamil}","u"),Z=new RegExp("\\p{Script=Telugu}","u"),q=new RegExp("\\p{Script=Thai}","u"),v=new RegExp("\\p{Script=Tibetan}","u"),Q=/[\u02BB\u02BC\u0027]/u,X=p=>p.replace(A,"");export{l as A,o as B,y as C,z as D,Z as E,j as F,f as G,q as H,k as I,v as J,J as K,F as L,h as M,V as N,n as O,r as P,u as Q,w as R,e as S,_ as T,I as U,i as V,S as W,s as X,O as a,A as b,C as c,x as d,B as e,t as f,N as g,T as h,g as i,L as j,c as k,H as l,D as m,b as n,P as o,m as p,Q as q,Y as r,X as s,U as t,$ as u,W as v,d as w,G as x,K as y,M as z};

package/dist/packem_shared/dedent-CPjAYUXh.js

@@ -0,0 +1 @@
+function I(e){const t=e.match(/^[ \t]*(?=\S)/gm);if(!t)return e;let n=Number.POSITIVE_INFINITY;for(const r of t)n=Math.min(n,r.length);return n===0||n===Number.POSITIVE_INFINITY?e:e.replace(new RegExp(`^[ \\t]{${n}}`,"gm"),"")}function c(e){const t=e.replace(/^(?:[ \t]*\r?\n)+|(?:\r?\n[ \t]*)+$/g,"");return I(t)}export{c as dedent,I as default};

package/dist/packem_shared/eastAsianWidth-DJV8Kqd-.js

@@ -0,0 +1 @@
+import{isFullWidth as s,isWide as o,isAmbiguous as r,getCategory as n}from"./_isFullWidth-Dqc3MWgl.js";function t(e){if(!Number.isSafeInteger(e))throw new TypeError(`Expected a code point, got \`${typeof e}\`.`)}function a(e){return t(e),n(e)}function d(e,{ambiguousAsWide:i=!1}={}){return t(e),s(e)||o(e)||i&&r(e)?2:1}export{s as _isFullWidth,o as _isWide,d as eastAsianWidth,a as eastAsianWidthType};

package/dist/packem_shared/generate-cache-key-B_0X7MKm.js

@@ -0,0 +1 @@
+const s=(r,n)=>`${r}::${n?.joiner??""}::${n?.locale??""}::${n?.knownAcronyms?.join(",")??""}::${n?.normalize?"true":"false"}::${n?.stripAnsi?"true":"false"}::${n?.stripEmoji?"true":"false"}::${n?.handleAnsi?"true":"false"}::${n?.handleEmoji?"true":"false"}`;export{s as a};

package/dist/packem_shared/indent-cz8WMI0e.js

@@ -0,0 +1 @@
+function i(e,t=1,r={}){const{indent:o=" ",includeEmptyLines:n=!1}=r;if(typeof e!="string")throw new TypeError(`Expected \`input\` to be a \`string\`, got \`${typeof e}\``);if(typeof t!="number")throw new TypeError(`Expected \`count\` to be a \`number\`, got \`${typeof t}\``);if(t<0)throw new RangeError(`Expected \`count\` to be at least 0, got \`${t}\``);if(typeof o!="string")throw new TypeError(`Expected \`options.indent\` to be a \`string\`, got \`${typeof o}\``);if(t===0)return e;const p=n?/^/gm:/^(?!\s*$)/gm;return e.replace(p,o.repeat(t))}export{i as default};

package/dist/packem_shared/joinSegments-CaHT-45s.js

@@ -0,0 +1 @@
+import{c as h}from"./constants-aPzGW29R.js";const l=(o,u)=>{const{length:r}=o;if(r===0)return"";if(r===1)return o[0];const t=[];let n="",e="";for(let f=0;f<r;f++){const s=o[f];if(h.test(s)){n?(t.push(n+e+s),n="",e=""):(t.length>0&&t.push(u),n=s);continue}n?(e&&(e+=u),e+=s):(t.length>0&&t.push(u),t.push(s))}return t.join("")};export{l as default};

package/dist/packem_shared/lru-cache-BtMSrYQJ.js

@@ -0,0 +1 @@
+class s{capacity;cache;constructor(e){this.capacity=e,this.cache=new Map}get(e){if(!this.cache.has(e))return;const c=this.cache.get(e);return this.cache.delete(e),this.cache.set(e,c),c}has(e){return this.cache.has(e)}set(e,c){if(this.cache.has(e))this.cache.delete(e);else if(this.cache.size>=this.capacity){const t=this.cache.keys().next().value;t!==void 0&&this.cache.delete(t)}this.cache.set(e,c)}delete(e){this.cache.delete(e)}clear(){this.cache.clear()}size(){return this.cache.size}}export{s as i};

package/dist/packem_shared/normalize-german-eszett-hNMwtGjd.js

@@ -0,0 +1 @@
+const e=/(?<![a-zß])SS(?![a-z])/g,l=a=>a.replaceAll(e,"ß");export{l as a};

package/dist/packem_shared/redent-ByOoJ6fN.js

@@ -0,0 +1 @@
+import f from"./indent-cz8WMI0e.js";import i from"./dedent-CPjAYUXh.js";function n(r,o=0,t={}){return f(i(r),o,t)}export{n as default};