@visulima/string 3.0.0-alpha.8 → 3.0.0

package/dist/index.js

@@ -1,39 +1 @@
-export { alignText } from './align-text.js';
-export { default as camelCase } from './case/camel-case.js';
-export { default as capitalCase } from './case/capital-case.js';
-export { default as constantCase } from './case/constant-case.js';
-export { default as dotCase } from './case/dot-case.js';
-export { default as flatCase } from './case/flat-case.js';
-export { flipCase } from './case/flip-case.js';
-export { default as identifyCase } from './case/identify-case.js';
-export { kebabCase } from './case/kebab-case.js';
-export { default as lowerFirst } from './case/lower-first.js';
-export { default as noCase } from './case/no-case.js';
-export { default as pascalCase } from './case/pascal-case.js';
-export { default as pascalSnakeCase } from './case/pascal-snake-case.js';
-export { default as pathCase } from './case/path-case.js';
-export { default as sentenceCase } from './case/sentence-case.js';
-export { default as snakeCase } from './case/snake-case.js';
-export { splitByCase } from './case/split-by-case.js';
-export { default as titleCase } from './case/title-case.js';
-export { default as trainCase } from './case/train-case.js';
-export { default as upperFirst } from './case/upper-first.js';
-export { default as joinSegments } from './packem_shared/joinSegments-BStLas0c.js';
-export { closestString } from './closest-string.js';
-export { compareSimilarity } from './compare-similarity.js';
-export { countOccurrences } from './packem_shared/countOccurrences-CS9XprQN.js';
-export { direction } from './packem_shared/direction-BVhR8MOQ.js';
-export { excerpt } from './packem_shared/excerpt-COsVNttN.js';
-export { getStringTruncatedWidth } from './get-string-truncated-width.js';
-export { getStringWidth } from './get-string-width.js';
-export { closestN } from './packem_shared/closestN-Cvsw0Fue.js';
-export { outdent } from './outdent.js';
-export { default as replaceString } from './packem_shared/replaceString-BVlxk27d.js';
-export { slice } from './slice.js';
-export { default as slugify } from './slugify.js';
-export { default as transliterate } from './packem_shared/transliterate-DGlx-woj.js';
-export { truncate } from './truncate.js';
-export { escapeRegExp, findStringOccurrences, hasChinese, hasPunctuationOrSpace, inRange } from './utilities.js';
-export { wordSimilaritySort } from './word-similarity-sort.js';
-export { WrapMode, wordWrap } from './word-wrap.js';
-export { closest, distance } from './packem_shared/closest-IHuSvnSn.js';
+import{alignText as r}from"./align-text.js";import{default as a}from"./case/camel-case.js";import{default as s}from"./case/capital-case.js";import{default as m}from"./case/constant-case.js";import{default as i}from"./case/dot-case.js";import{default as d}from"./case/flat-case.js";import{flipCase as u}from"./case/flip-case.js";import{default as C}from"./case/identify-case.js";import{kebabCase as S}from"./case/kebab-case.js";import{default as y}from"./case/lower-first.js";import{default as w}from"./case/no-case.js";import{default as F}from"./case/pascal-case.js";import{default as T}from"./case/pascal-snake-case.js";import{default as A}from"./case/path-case.js";import{default as R}from"./case/sentence-case.js";import{default as B}from"./case/snake-case.js";import{splitByCase as I}from"./case/split-by-case.js";import{default as N}from"./case/title-case.js";import{default as v}from"./case/train-case.js";import{default as D}from"./case/upper-first.js";import{default as H}from"./packem_shared/joinSegments-CaHT-45s.js";import{closestString as K}from"./closest-string.js";import{compareSimilarity as Q}from"./compare-similarity.js";import{countOccurrences as V}from"./count-occurrences.js";import{direction as Y}from"./direction.js";import{excerpt as _}from"./excerpt.js";import{getStringTruncatedWidth as ee}from"./get-string-truncated-width.js";import{getStringWidth as re}from"./get-string-width.js";import{default as ae}from"./is-fullwidth-code-point.js";import{closestN as se,similarity as pe}from"./levenshtein.js";import{outdent as xe}from"./outdent.js";import{default as le}from"./replace-string.js";import{slice as ne}from"./slice.js";import{default as ce}from"./slugify.js";import{default as ge}from"./transliterate.js";import{truncate as he}from"./truncate.js";import{escapeRegExp as We,findStringOccurrences as we,hasChinese as ke,hasPunctuationOrSpace as Fe,inRange as Oe}from"./utilities.js";import{wordSimilaritySort as be}from"./word-similarity-sort.js";import{WrapMode as Pe,wordWrap as Re}from"./word-wrap.js";import{default as Be}from"./packem_shared/indent-cz8WMI0e.js";import{default as Ie}from"./packem_shared/redent-ByOoJ6fN.js";import{dedent as Ne,default as qe}from"./packem_shared/dedent-CPjAYUXh.js";import{closest as ze,distance as De}from"./packem_shared/closest-C6YDQs4m.js";import{eastAsianWidth as He,eastAsianWidthType as Je}from"./packem_shared/eastAsianWidth-DJV8Kqd-.js";export{Pe as WrapMode,r as alignText,a as camelCase,s as capitalCase,ze as closest,se as closestN,K as closestString,Q as compareSimilarity,m as constantCase,V as countOccurrences,Ne as dedent,Y as direction,De as distance,i as dotCase,He as eastAsianWidth,Je as eastAsianWidthType,We as escapeRegExp,_ as excerpt,we as findStringOccurrences,d as flatCase,u as flipCase,ee as getStringTruncatedWidth,re as getStringWidth,ke as hasChinese,Fe as hasPunctuationOrSpace,C as identifyCase,Oe as inRange,Be as indent,ae as isFullwidthCodePoint,H as joinSegments,S as kebabCase,y as lowerFirst,w as noCase,xe as outdent,F as pascalCase,T as pascalSnakeCase,A as pathCase,Ie as redent,le as replaceString,R as sentenceCase,pe as similarity,ne as slice,ce as slugify,B as snakeCase,I as splitByCase,qe as stripIndent,N as titleCase,v as trainCase,ge as transliterate,he as truncate,D as upperFirst,be as wordSimilaritySort,Re as wordWrap};

package/dist/is-fullwidth-code-point.d.ts

@@ -0,0 +1,7 @@
+/**
+* Check if the given code point is a fullwidth character.
+* @param codePoint The code point to check.
+* @returns Whether the code point is a fullwidth character.
+*/
+declare const isFullwidthCodePoint: (codePoint: number) => boolean;
+export { isFullwidthCodePoint as default };

package/dist/is-fullwidth-code-point.js

@@ -0,0 +1 @@
+import{isFullWidth as i,isWide as t}from"./packem_shared/_isFullWidth-Dqc3MWgl.js";const r=s=>Number.isInteger(s)?i(s)||t(s):!1;export{r as default};

package/dist/levenshtein.d.ts

@@ -0,0 +1,25 @@
+declare const distance: (a: string, b: string) => number;
+declare const closest: (str: string, arr: readonly string[]) => string;
+declare const closestN: (string_: string, array: ReadonlyArray<string>, n: number) => (string | undefined)[];
+/**
+* Computes a normalized similarity score between two strings in the range `[0, 1]`,
+* where `1` means the strings are identical and `0` means maximally different.
+*
+* The score is derived from the Levenshtein edit distance, normalized by the
+* length of the longer string: `1 - distance(a, b) / max(a.length, b.length)`.
+* Two empty strings are considered identical (`1`).
+*
+* This is convenient for threshold-based "did you mean?" UX, complementing the
+* raw {@link distance} and the sort-based helpers.
+* @example
+* ```typescript
+* similarity("kitten", "sitting"); // => ~0.571
+* similarity("foo", "foo");        // => 1
+* similarity("", "");              // => 1
+* ```
+* @param a The first string.
+* @param b The second string.
+* @returns A similarity score between 0 and 1 (inclusive).
+*/
+declare const similarity: (a: string, b: string) => number;
+export { closest, closestN, distance, similarity };

package/dist/levenshtein.js

@@ -0,0 +1 @@
+import{distance as c}from"./packem_shared/closest-C6YDQs4m.js";import{closest as y}from"./packem_shared/closest-C6YDQs4m.js";const u=(r,s,o)=>{const e=Array.from({length:o}).fill(1/0),n=Array.from({length:o}).fill(void 0);for(const a of s){const f=a;let l=c(r,f),i=f;for(let t=0;t<o;t+=1)if(l<e[t]){const m=e[t],h=n[t];e[t]=l,n[t]=i,l=m,i=h}}return n},d=(r,s)=>{if(r===s)return 1;const o=Math.max(r.length,s.length);return o===0?1:1-c(r,s)/o};export{y as closest,u as closestN,c as distance,d as similarity};

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-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 {

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,117 +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-D5qaproB.js';
-
-const hop = Object.prototype.hasOwnProperty;
-const has = (object, property) => hop.call(object, property);
-const extend = (target, source) => {
-  for (const property of Object.keys(source)) {
-    target[property] = source[property];
-  }
-  return target;
-};
-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");
-  if (firstInterpolatedValueSetsIndentationLevel) {
-    strings = strings.slice(1);
-  }
-  const { newline, trimLeadingNewline, trimTrailingNewline } = options;
-  const normalizeNewlines = typeof newline === "string";
-  const l = strings.length;
-  const outdentedStrings = Array.from({ length: l });
-  for (let index = 0; index < l; index++) {
-    let v = strings[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-BqU1Cqwm.js

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

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};