@visulima/string 3.0.0-alpha.1 → 3.0.0-alpha.11

package/dist/index.d.ts

@@ -1,47 +1,51 @@
-export { AlignTextOptions, 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 { FlipOptions, flipCase } from './case/flip-case.js';
-export { default as identifyCase } from './case/identify-case.js';
-export { KebabCaseOptions, 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 { SplitOptions, 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 { a as CamelCase, b as CapitalCase, C as CaseOptions, c as ConstantCase, D as DotCase, F as FlatCase, d as FlipCase, I as IdentifyCase, K as KebabCase, L as LocaleOptions, e as LowerFirst, N as NoCase, P as PascalCase, f as PascalSnakeCase, g as PathCase, S as SentenceCase, h as SnakeCase, i as SplitByCase, T as TitleCase, j as TrainCase, U as UpperFirst } from './packem_shared/types-CfPsw9ix.js';
-export { default as upperFirst } from './case/upper-first.js';
-export { joinSegments } from './case/index.js';
-export { ClosestStringOptions, closestString } from './closest-string.js';
-export { CompareSimilarityOptions, compareSimilarity } from './compare-similarity.js';
-export { StringTruncatedWidthOptions, StringTruncatedWidthResult, getStringTruncatedWidth } from './get-string-truncated-width.js';
-export { StringWidthOptions, getStringWidth } from './get-string-width.js';
-export { Outdent, Options as OutdentOptions, outdent } from './outdent.js';
-import { O as OptionReplaceArray, l as IntervalArray, m as OptionsTransliterate } from './packem_shared/types-Daae0hGf.js';
-export { A as All, n as Any, C as CharAt, o as Charmap, a as Concat, E as EndsWith, I as Includes, p as Interval, q as IsBooleanLiteral, r as IsNumberLiteral, k as IsStringLiteral, s as IsStringLiteralArray, J as Join, L as Length, M as Math, N as NodeLocale, t as OptionReplaceCombined, u as OptionReplaceObject, P as PadEnd, b as PadStart, v as Repeat, R as Replace, c as ReplaceAll, w as Reverse, S as Slice, j as SlugifyOptions, d as Split, e as StartsWith, T as ToLowerCase, f as ToUpperCase, g as Trim, h as TrimEnd, i as TrimStart } from './packem_shared/types-Daae0hGf.js';
-export { SliceOptions, slice } from './slice.js';
-export { default as slugify } from './slugify.js';
-export { TruncateOptions, truncate } from './truncate.js';
-export { escapeRegExp, findStringOccurrences, hasChinese, hasPunctuationOrSpace, inRange } from './utilities.js';
-export { WordSimilaritySortOptions, wordSimilaritySort } from './word-similarity-sort.js';
-export { WordWrapOptions, WrapMode, wordWrap } from './word-wrap.js';
-import './packem_shared/lru-cache-B_t27XwI.js';
-
-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 | null)[];
-
+export { type AlignTextOptions, 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 { type FlipOptions, flipCase } from "./case/flip-case.js";
+export { default as identifyCase } from "./case/identify-case.js";
+export { type KebabCaseOptions, 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 { type SplitOptions, 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 { type a as CamelCase, type b as CapitalCase, type C as CaseOptions, type c as ConstantCase, type D as DotCase, type F as FlatCase, type d as FlipCase, type I as IdentifyCase, type K as KebabCase, type L as LocaleOptions, type e as LowerFirst, type N as NoCase, type P as PascalCase, type f as PascalSnakeCase, type g as PathCase, type S as SentenceCase, type h as SnakeCase, type i as SplitByCase, type T as TitleCase, type j as TrainCase, type U as UpperFirst } from "./packem_shared/types.d-DfgbcNKh.js";
+export { default as upperFirst } from "./case/upper-first.js";
+export { joinSegments } from "./case/index.js";
+export { type ClosestStringOptions, closestString } from "./closest-string.js";
+export { type CompareSimilarityOptions, compareSimilarity } from "./compare-similarity.js";
+export { type Options as EastAsianWidthOptions, type WidthType as EastAsianWidthType, eastAsianWidth, eastAsianWidthType } from 'get-east-asian-width';
+import { TruncateOptions } from "./truncate.js";
+export { truncate } from "./truncate.js";
+export { type StringTruncatedWidthOptions, type StringTruncatedWidthResult, getStringTruncatedWidth } from "./get-string-truncated-width.js";
+export { type StringWidthOptions, getStringWidth } from "./get-string-width.js";
+export { type Options as IndentOptions, default as indent } from 'indent-string';
+export { default as redent } from 'redent';
+export { dedent, default as stripIndent } from 'strip-indent';
+export { type Outdent, type Options as OutdentOptions, outdent } from "./outdent.js";
+import { O as OptionReplaceArray, a as IntervalArray, b as OptionsTransliterate } from "./packem_shared/types.d-BVNv675q.js";
+export { type A as All, type c as Any, type C as CharAt, type d as Charmap, type e as Concat, type E as EndsWith, type f as Includes, type g as Interval, type h as IsBooleanLiteral, type i as IsNumberLiteral, type I as IsStringLiteral, type j as IsStringLiteralArray, type J as Join, type L as Length, type M as Math, type N as NodeLocale, type k as OptionReplaceCombined, type l as OptionReplaceObject, type P as PadEnd, type m as PadStart, type R as Repeat, type n as Replace, type o as ReplaceAll, type p as Reverse, type q as Slice, type S as SlugifyOptions, type r as Split, type s as StartsWith, type T as ToLowerCase, type t as ToUpperCase, type u as Trim, type v as TrimEnd, type w as TrimStart } from "./packem_shared/types.d-BVNv675q.js";
+export { type SliceOptions, slice } from "./slice.js";
+export { default as slugify } from "./slugify.js";
+export { escapeRegExp, findStringOccurrences, hasChinese, hasPunctuationOrSpace, inRange } from "./utilities.js";
+export { type WordSimilaritySortOptions, wordSimilaritySort } from "./word-similarity-sort.js";
+export { type WordWrapOptions, WrapMode, wordWrap } from "./word-wrap.js";
+export { closest, distance } from 'fastest-levenshtein';
+import "./packem_shared/lru-cache.d-BsP6kbVJ.js";
+declare const countOccurrences: (value: unknown, substring: string) => number;
+declare const direction: (value?: string) => "rtl" | "ltr" | "neutral";
+declare const excerpt: (html: string, limit: number, options?: ExcerptOptions) => string;
+type ExcerptOptions = Omit<TruncateOptions, "position">;
+declare const isFullwidthCodePoint: (codePoint: number) => boolean;
+declare const closestN: (string_: string, array: ReadonlyArray<string>, n: number) => (string | undefined)[];
 declare const replaceString: (source: string, searches: OptionReplaceArray, ignoreRanges: IntervalArray) => string;
-
 declare const transliterate: (source: string, options?: OptionsTransliterate) => string;
-
-export { IntervalArray, OptionReplaceArray, OptionsTransliterate, closest, closestN, distance, replaceString, transliterate };
+export { type ExcerptOptions, type IntervalArray, type OptionReplaceArray, type OptionsTransliterate, type TruncateOptions, closestN, countOccurrences, direction, excerpt, isFullwidthCodePoint, replaceString, transliterate };

package/dist/index.js

@@ -18,19 +18,27 @@ 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-CuU8RGpP.js';
+export { default as joinSegments } from './packem_shared/joinSegments-CvxSgKz0.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-C9gfWWTK.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-BREy4E7C.js';
+export { default as isFullwidthCodePoint } from './packem_shared/isFullwidthCodePoint-IFXZxNjq.js';
+export { closestN } from './packem_shared/closestN-DUsjgiXb.js';
 export { outdent } from './outdent.js';
-export { default as replaceString } from './packem_shared/replaceString-vYvRBMfC.js';
+export { default as replaceString } from './packem_shared/replaceString-Ce8X2ZQ-.js';
 export { slice } from './slice.js';
 export { default as slugify } from './slugify.js';
-export { default as transliterate } from './packem_shared/transliterate-CYnKKT8f.js';
+export { default as transliterate } from './packem_shared/transliterate-CKt9VK7D.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 { default as indent } from './packem_shared/indent-D3DSCa6s.js';
+export { default as redent } from './packem_shared/redent-DSb1IJWn.js';
+export { dedent, default as stripIndent } from './packem_shared/stripIndent-D_TRjxZ_.js';
 export { closest, distance } from './packem_shared/closest-IHuSvnSn.js';
+export { eastAsianWidth, eastAsianWidthType } from './packem_shared/eastAsianWidthType-SD3YniiT.js';

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

@@ -1,130 +1,147 @@
-import { C as CharAt, a as Concat, E as EndsWith, I as Includes, L as Length, P as PadEnd, b as PadStart, R as Replace, c as ReplaceAll, S as Slice, d as Split, e as StartsWith, T as ToLowerCase, f as ToUpperCase, g as Trim, h as TrimEnd, i as TrimStart } from './packem_shared/types-Daae0hGf.js';
-
-/* eslint-disable @typescript-eslint/method-signature-style */
-
+type TupleOf<L extends number, T = unknown, Result extends any[] = []> = Result["length"] extends L ? Result : TupleOf<L, T, [...Result, T]>;
+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;
+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;
+type EndsWithNoPositionType<T extends string, S extends string> = StartsWith<Reverse<T>, Reverse<S>>;
+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 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 Reverse<T extends string, Accumulator extends string = ""> = T extends `${infer Head}${infer Tail}` ? Reverse<Tail, `${Head}${Accumulator}`> : Accumulator extends "" ? T : `${T}${Accumulator}`;
+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 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 CharAt<T extends string, Index extends number> = All<[IsStringLiteral<T>, IsNumberLiteral<Index>]> extends true ? Split<T>[Index] : string;
+type Concat<T extends string[]> = Join<T>;
+type EndsWith<T extends string, S extends string, P extends number | undefined = undefined> = P extends number ? InternalEndsWithType<T, S, P> : EndsWithNoPositionType<T, S>;
+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 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 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 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 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 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 Slice<T extends string, StartIndex extends number = 0, EndIndex extends number | undefined = undefined> = EndIndex extends number ? InternalSliceType<T, StartIndex, EndIndex> : SliceStartType<T, StartIndex>;
+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 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 TrimEnd<T extends string> = T extends `${infer Rest} ` ? TrimEnd<Rest> : T;
+type TrimStart<T extends string> = T extends ` ${infer Rest}` ? TrimStart<Rest> : T;
+type Trim<T extends string> = TrimEnd<TrimStart<T>>;
+type ToLowerCase<T extends string> = IsStringLiteral<T> extends true ? Lowercase<T> : string;
+type ToUpperCase<T extends string> = IsStringLiteral<T> extends true ? Uppercase<T> : string;
 declare global {
-    interface String {
-        /**
-         * Returns the character at the specified index.
-         * @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
-         * position; otherwise, returns false.
-         * @param searchString
-         * @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.
-         * @param maxLength The length of the resulting string once the current string has been padded.
-         * @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.
-         * @param maxLength The length of the resulting string once the current string has been padded.
-         * @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.
-         */
-        trimStart<T extends string = string>(this: T): TrimStart<T>;
-    }
+  interface String {
+    /**
+     * Returns the character at the specified index.
+     * @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
+     * position; otherwise, returns false.
+     * @param searchString
+     * @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.
+     * @param maxLength The length of the resulting string once the current string has been padded.
+     * @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.
+     * @param maxLength The length of the resulting string once the current string has been padded.
+     * @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.
+     */
+    trimStart<T extends string = string>(this: T): TrimStart<T>;
+  }
 }

package/dist/outdent.d.ts

@@ -1,16 +1,14 @@
 declare const outdent: Outdent;
 interface Outdent {
-    (strings: TemplateStringsArray, ...values: any[]): string;
-    (options: Options): Outdent;
-    string: (string_: string) => string;
+  (strings: TemplateStringsArray, ...values: any[]): string;
+  (options: Options): Outdent;
+  string: (string_: string) => string;
 }
 interface Options {
-    cache?: boolean;
-    cacheStore?: WeakMap<TemplateStringsArray, string[]>;
-    newline?: string | null;
-    trimLeadingNewline?: boolean;
-    trimTrailingNewline?: boolean;
+  cache?: boolean;
+  cacheStore?: WeakMap<TemplateStringsArray, string[]>;
+  newline?: string | null;
+  trimLeadingNewline?: boolean;
+  trimTrailingNewline?: boolean;
 }
-
-export { outdent };
-export type { Options, Outdent };
+export { Options, Outdent, outdent };

package/dist/outdent.js

@@ -1,13 +1,7 @@
-import { d as RE_LEADING_NEWLINE, e as RE_TRAILING_NEWLINE, f as RE_ONLY_WHITESPACE_WITH_AT_LEAST_ONE_NEWLINE, g as RE_STARTS_WITH_NEWLINE_OR_IS_EMPTY, h as RE_DETECT_INDENTATION, i as RE_MATCH_NEWLINES } from './packem_shared/constants-CTzC6Gjg.js';
+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 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 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 [];
@@ -19,15 +13,13 @@ const internalOutdentArray = (strings, firstInterpolatedValueSetsIndentationLeve
   }
   const reSource = String.raw`(\r\n|\r|\n).{0,${indentationLevel}}`;
   const reMatchIndent = new RegExp(reSource, "g");
-  if (firstInterpolatedValueSetsIndentationLevel) {
-    strings = strings.slice(1);
-  }
+  const processedStrings = firstInterpolatedValueSetsIndentationLevel ? strings.slice(1) : strings;
   const { newline, trimLeadingNewline, trimTrailingNewline } = options;
   const normalizeNewlines = typeof newline === "string";
-  const l = strings.length;
+  const l = processedStrings.length;
   const outdentedStrings = Array.from({ length: l });
   for (let index = 0; index < l; index++) {
-    let v = strings[index];
+    let v = processedStrings[index];
     v = v.replace(reMatchIndent, "$1");
     if (index === 0 && trimLeadingNewline) {
       v = v.replace(RE_LEADING_NEWLINE, "");
@@ -57,7 +49,7 @@ 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 : null;
+  const cache = enableCache ? options.cacheStore ?? templateCache : void 0;
   const hasNewlineOption = options.newline !== void 0;
   function outdent2(stringsOrOptions, ...values) {
     if (isTemplateStringsArray(stringsOrOptions)) {

package/dist/packem_shared/closestN-DUsjgiXb.js

@@ -0,0 +1,25 @@
+import { distance } from './closest-IHuSvnSn.js';
+export { closest } from './closest-IHuSvnSn.js';
+
+const closestN = (string_, array, n) => {
+  const distances = Array.from({ length: n }).fill(Infinity);
+  const values = Array.from({ length: n }).fill(void 0);
+  for (const element of array) {
+    const candidateValue = element;
+    let currentDistance = distance(string_, candidateValue);
+    let currentValue = candidateValue;
+    for (let index = 0; index < n; index += 1) {
+      if (currentDistance < distances[index]) {
+        const temporaryDistance = distances[index];
+        const temporaryValue = values[index];
+        distances[index] = currentDistance;
+        values[index] = currentValue;
+        currentDistance = temporaryDistance;
+        currentValue = temporaryValue ?? "";
+      }
+    }
+  }
+  return values;
+};
+
+export { closestN, distance };

package/dist/packem_shared/{constants-CTzC6Gjg.js → constants-BsZS5f0z.js}

@@ -92,4 +92,4 @@ const RE_TIBETAN = new RegExp("\\p{Script=Tibetan}", "u");
 const RE_UZBEK_LATIN_MODIFIER = /[\u02BB\u02BC\u0027]/u;
 const stripEmoji = (stringValue) => stringValue.replace(RE_EMOJI, "");
 
-export { RE_GURMUKHI as A, RE_KANNADA as B, RE_TAMIL as C, RE_TELUGU as D, RE_MALAYALAM as E, RE_SINHALA as F, RE_THAI as G, RE_LAO as H, RE_TIBETAN as I, RE_MYANMAR as J, RE_ETHIOPIC as K, RE_KHMER as L, RE_ORIYA as M, RE_CONTROL as N, ESCAPES as O, ANSI_ESCAPE_LINK as P, ANSI_SGR_TERMINATOR as Q, RE_FAST_ANSI as R, ANSI_ESCAPE_BELL as S, ANSI_CSI as T, RE_ESCAPE_PATTERN as U, ANSI_RESET_CODES as V, END_CODE as W, RE_ZERO_WIDTH as X, RE_VALID_ANSI_PAIRS as a, RE_VALID_HYPERLINKS as b, RE_ANSI as c, RE_LEADING_NEWLINE as d, RE_TRAILING_NEWLINE as e, RE_ONLY_WHITESPACE_WITH_AT_LEAST_ONE_NEWLINE as f, RE_STARTS_WITH_NEWLINE_OR_IS_EMPTY as g, RE_DETECT_INDENTATION as h, RE_MATCH_NEWLINES as i, RE_EMOJI as j, RE_SEPARATORS as k, RE_CYRILLIC as l, RE_LATIN as m, RE_GREEK as n, RE_GREEK_LATIN_SPLIT as o, RE_UZBEK_LATIN_MODIFIER as p, RE_KATAKANA as q, RE_KANJI as r, stripEmoji as s, RE_HIRAGANA as t, RE_HANGUL as u, RE_HEBREW as v, RE_ARABIC as w, RE_DEVANAGARI as x, RE_BENGALI as y, RE_GUJARATI as z };
+export { RE_GUJARATI as A, RE_GURMUKHI as B, RE_KANNADA as C, RE_TAMIL as D, RE_TELUGU as E, RE_MALAYALAM as F, RE_SINHALA as G, RE_THAI as H, RE_LAO as I, RE_TIBETAN as J, RE_MYANMAR as K, RE_ETHIOPIC as L, RE_KHMER as M, RE_ORIYA as N, ESCAPES as O, ANSI_ESCAPE_LINK as P, ANSI_SGR_TERMINATOR as Q, RE_FAST_ANSI as R, ANSI_ESCAPE_BELL as S, ANSI_CSI as T, RE_ESCAPE_PATTERN as U, ANSI_RESET_CODES as V, END_CODE as W, RE_ZERO_WIDTH as X, RE_LEADING_NEWLINE as a, RE_TRAILING_NEWLINE as b, RE_ONLY_WHITESPACE_WITH_AT_LEAST_ONE_NEWLINE as c, RE_STARTS_WITH_NEWLINE_OR_IS_EMPTY as d, RE_MATCH_NEWLINES as e, RE_DETECT_INDENTATION as f, RE_ANSI as g, RE_CONTROL as h, RE_EMOJI as i, RE_VALID_ANSI_PAIRS as j, RE_VALID_HYPERLINKS as k, RE_CYRILLIC as l, RE_LATIN as m, RE_GREEK as n, RE_GREEK_LATIN_SPLIT as o, RE_UZBEK_LATIN_MODIFIER as p, RE_KATAKANA as q, RE_KANJI as r, stripEmoji as s, RE_HIRAGANA as t, RE_HANGUL as u, RE_HEBREW as v, RE_ARABIC as w, RE_SEPARATORS as x, RE_DEVANAGARI as y, RE_BENGALI as z };

package/dist/packem_shared/countOccurrences-CS9XprQN.js

@@ -0,0 +1,22 @@
+const countOccurrences = (value, substring) => {
+  const source = String(value);
+  if (typeof substring !== "string") {
+    throw new TypeError("Expected character");
+  }
+  if (substring.length === 0) {
+    throw new TypeError("Expected non-empty substring");
+  }
+  let count = 0;
+  let index = source.indexOf(substring);
+  while (index !== -1) {
+    count++;
+    const nextIndex = index + substring.length;
+    if (nextIndex <= index) {
+      break;
+    }
+    index = source.indexOf(substring, nextIndex);
+  }
+  return count;
+};
+
+export { countOccurrences };

package/dist/packem_shared/direction-C9gfWWTK.js

@@ -0,0 +1,16 @@
+const rtlRange = "֑-߿יִ-﷽ﹰ-ﻼ";
+const ltrRange = "A-Za-zÀ-ÖØ-öø-ʸ̀-֐ࠀ-῿‎Ⰰ-﬜︀-﹯﻽-￿";
+const rtl = new RegExp(`^[^${ltrRange}]*[${rtlRange}]`);
+const ltr = new RegExp(`^[^${rtlRange}]*[${ltrRange}]`);
+const direction = (value = "") => {
+  const source = value;
+  if (rtl.test(source)) {
+    return "rtl";
+  }
+  if (ltr.test(source)) {
+    return "ltr";
+  }
+  return "neutral";
+};
+
+export { direction };

package/dist/packem_shared/eastAsianWidthType-SD3YniiT.js

@@ -0,0 +1,20 @@
+import { i as isFullWidth, a as isWide, b as isAmbiguous, g as getCategory } from './lookup-BE8lEqy4.js';
+
+function validate(codePoint) {
+  if (!Number.isSafeInteger(codePoint)) {
+    throw new TypeError(`Expected a code point, got \`${typeof codePoint}\`.`);
+  }
+}
+function eastAsianWidthType(codePoint) {
+  validate(codePoint);
+  return getCategory(codePoint);
+}
+function eastAsianWidth(codePoint, { ambiguousAsWide = false } = {}) {
+  validate(codePoint);
+  if (isFullWidth(codePoint) || isWide(codePoint) || ambiguousAsWide && isAmbiguous(codePoint)) {
+    return 2;
+  }
+  return 1;
+}
+
+export { isFullWidth as _isFullWidth, isWide as _isWide, eastAsianWidth, eastAsianWidthType };