@avstantso/std-ext 1.0.2 → 1.2.1

package/CHANGELOG.md

@@ -1,7 +1,29 @@
 # Changelog
 
+
+## [1.2.1] - 2026-01-18
+
+### Changed
+
+- Fix publishing
+
 All notable changes to this project will be documented in this file.
 
+## [1.1.0] - 2026-01-18
+
+### Added
+
+- `Object.definePropertyOnce` - adds property only if not exists
+- `Object.definePropertiesOnce` - adds multiple properties only if not exist
+- `RegExp.escape` - escape all RegExp special characters in a string (TC39 proposal polyfill)
+- `Symbol.Has` - factory function to check and cast symbol in object
+
+### Changed
+
+- Reorganized extensions to `_std-ext/` directory structure
+- `Array.prototype` and `String.prototype` extensions now use `definePropertiesOnce`
+- `toCapitalized()` and `toUncapitalized()` now preserve string literal types
+
 ## [1.0.2] - 2026-01-15
 
 ### Fixed

package/README.md

@@ -3,7 +3,7 @@
 [![npm version](https://img.shields.io/npm/v/@avstantso/std-ext.svg)](https://www.npmjs.com/package/@avstantso/std-ext)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-Standard JavaScript objects extension with zero dependencies. Adds useful methods to native String and Array prototypes with full TypeScript support.
+Standard JavaScript objects extension with zero dependencies. Adds useful methods to native String, Array, RegExp, Object, and Symbol with full TypeScript support.
 
 ## Features
 
@@ -32,39 +32,173 @@ Simply import the package once in your application entry point to enable all ext
 ```typescript
 import '@avstantso/std-ext';
 
-// Now all String and Array methods are available
+// Now all extensions are available
 const greeting = "hello".toCapitalized(); // "Hello"
 const items = [1, 0, 2, null, 3, false, 4].pack(); // [1, 2, 3, 4]
+const escaped = RegExp.escape("file[1].txt"); // "file\\[1\\]\\.txt"
 ```
 
 ## API Reference
 
+### RegExp Extensions
+
+#### `RegExp.escape(str)`
+
+Escapes all RegExp special characters in a string, making it safe to use in `new RegExp()`. This is a polyfill for the [TC39 RegExp.escape proposal](https://tc39.es/proposal-regex-escaping/).
+
+**Parameters:**
+- `str: string` - The string to escape
+
+**Returns:** `string` - New string with escaped RegExp characters
+
+**Escaped characters:** `\ ^ $ . * + ? ( ) [ ] { } |`
+
+**Example:**
+```typescript
+RegExp.escape("file[1].txt");     // "file\\[1\\]\\.txt"
+RegExp.escape("price: $10.00");   // "price: \\$10\\.00"
+RegExp.escape("a+b=c?");          // "a\\+b=c\\?"
+
+// Safe dynamic RegExp creation
+const userInput = "test.file[1]";
+const regex = new RegExp(RegExp.escape(userInput));
+regex.test("test.file[1]"); // true
+regex.test("testXfile11");  // false
+```
+
+### Object Extensions
+
+#### `Object.definePropertyOnce(o, p, attributes)`
+
+Adds a property to an object only if it doesn't already exist. Useful for polyfills and non-intrusive extensions. Especially handy for hot module replacement (HMR) environments like Vite, Webpack, or Parcel where modules may be re-executed multiple times.
+
+**Parameters:**
+- `o: T` - Object on which to add the property
+- `p: PropertyKey` - The property name
+- `attributes: PropertyDescriptor` - Descriptor for the property
+
+**Returns:** `T` - The object passed in
+
+**Example:**
+```typescript
+const obj = { existing: 1 };
+
+Object.definePropertyOnce(obj, 'existing', { value: 999 });
+Object.definePropertyOnce(obj, 'newProp', { value: 2 });
+
+console.log(obj.existing); // 1 (unchanged)
+console.log(obj.newProp);  // 2 (added)
+
+// Useful for polyfills
+Object.definePropertyOnce(String.prototype, 'myMethod', {
+  value() { return this.toUpperCase(); }
+});
+```
+
+#### `Object.definePropertiesOnce(o, properties)`
+
+Adds multiple properties to an object, skipping any that already exist. Same HMR benefits as `definePropertyOnce`.
+
+**Parameters:**
+- `o: T` - Object on which to add the properties
+- `properties: PropertyDescriptorMap` - Object containing property descriptors
+
+**Returns:** `T` - The object passed in
+
+**Example:**
+```typescript
+const obj = { a: 1 };
+
+Object.definePropertiesOnce(obj, {
+  a: { value: 999 },  // skipped - already exists
+  b: { value: 2 },    // added
+  c: { value: 3 }     // added
+});
+
+console.log(obj); // { a: 1, b: 2, c: 3 }
+```
+
+### Symbol Extensions
+
+#### `Symbol.Has(symb, resultTemplate?)`
+
+Creates a type guard function that checks if an object has a specific symbol property. Returns a reusable checker function with proper TypeScript type narrowing.
+
+**Parameters:**
+- `symb: symbol` - The symbol to check for
+- `resultTemplate?: R` - Optional type-only argument to infer the symbol's value type (not used at runtime)
+
+**Returns:** `(obj: unknown) => obj is { [K in Symb]: R }` - Type guard function
+
+**Example:**
+```typescript
+const mySymbol = Symbol('mySymbol');
+const hasMySymbol = Symbol.Has(mySymbol);
+
+const obj1 = { [mySymbol]: 'value' };
+const obj2 = { foo: 'bar' };
+
+hasMySymbol(obj1); // true
+hasMySymbol(obj2); // false
+hasMySymbol(null); // false (safe with nullish values)
+
+// Works great with well-known symbols
+const hasIterator = Symbol.Has(Symbol.iterator);
+
+hasIterator([]);        // true
+hasIterator('string');  // true
+hasIterator(new Map()); // true
+hasIterator({});        // false
+
+// Type narrowing in conditionals
+const data: unknown = getExternalData();
+if (hasIterator(data)) {
+  for (const item of data) { ... } // TypeScript knows data is iterable
+}
+
+// With typed value using resultTemplate
+const symbolFreeze = Symbol('freeze');
+const hasFreeze = Symbol.Has(symbolFreeze, () => {});
+
+if (hasFreeze(obj)) {
+  obj[symbolFreeze](); // TypeScript knows it's () => void
+}
+```
+
 ### String Extensions
 
 #### `toCapitalized()`
 
 Capitalizes the first character of the string.
 
-**Returns:** `Capitalize<string>`
+**Returns:** `Capitalize<S>` where `S` is the string literal type
 
 **Example:**
 ```typescript
 "hello".toCapitalized(); // "Hello"
 "world".toCapitalized(); // "World"
 "".toCapitalized();      // ""
+
+// Preserves literal types
+const a = 'foo' as const;
+const b = a.toCapitalized(); // type is 'Foo', not string
 ```
 
 #### `toUncapitalized()`
 
 Uncapitalizes the first character of the string.
 
-**Returns:** `Uncapitalize<string>`
+**Returns:** `Uncapitalize<S>` where `S` is the string literal type
 
 **Example:**
 ```typescript
 "Hello".toUncapitalized(); // "hello"
 "World".toUncapitalized(); // "world"
 "".toUncapitalized();      // ""
+
+// Preserves literal types
+const a = 'FOO' as const;
+const b = a.toUncapitalized(); // type is 'fOO', not string
 ```
 
 ### Array Extensions
@@ -82,6 +216,39 @@ Filters out all falsy values from the array (false, 0, "", null, undefined, NaN)
 [1, 0, 2, null, 3, false, 4].pack();           // [1, 2, 3, 4]
 ["a", "", "b", null, "c"].pack();              // ["a", "b", "c"]
 [true, false, true, undefined].pack();         // [true, true]
+
+// Real world example: React conditional CSS classes
+function Button({ isActive, isDisabled, isLoading }) {
+  return (
+    <button
+      className={[
+        'btn',
+        isActive && 'btn--active',
+        isDisabled && 'btn--disabled',
+        isLoading && 'btn--loading'
+      ].pack().join(' ')}
+    >
+      Click me
+    </button>
+  );
+}
+
+// Compare to the alternative without pack():
+function Button({ isActive, isDisabled, isLoading }) {
+  return (
+    <button
+      className={`btn${
+        isActive ? ' btn--active' : ''
+      }${
+        isDisabled ? ' btn--disabled' : ''
+      }${
+        isLoading ? ' btn--loading' : ''
+      }`}
+    >
+      Click me
+    </button>
+  );
+}
 ```
 
 #### `peek()`

package/dist/_std-ext/index.d.ts

@@ -0,0 +1,5 @@
+import './object';
+import './symbol';
+import './array';
+import './string';
+import './reg-exp';

package/dist/_std-ext/object.d.ts

@@ -0,0 +1,17 @@
+interface ObjectConstructor {
+    /**
+     * Adds a property to an object (if it's not exists).
+     * @param o Object on which to add the property.\
+     * This can be a native JavaScript object (that is, a user-defined object or a built in object) or a DOM object.
+     * @param p The property name.
+     * @param attributes Descriptor for the property. It can be for a data property or an accessor property.
+     */
+    definePropertyOnce: ObjectConstructor['defineProperty'];
+    /**
+     * Adds one or more properties to an object (if it's not exists).
+     * @param o Object on which to add or modify the properties. This can be a native JavaScript object or a DOM object.
+     * @param properties JavaScript object that contains one or more descriptor objects.\
+     * Each descriptor object describes a data property or an accessor property.
+    */
+    definePropertiesOnce: ObjectConstructor['defineProperties'];
+}

package/dist/_std-ext/reg-exp.d.ts

@@ -0,0 +1,9 @@
+interface RegExpConstructor {
+    /**
+     * @summary Escape all `RegExp` special characters in a string
+     * @returns New string with escaped `RegExp` characters
+     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/escape
+     * @see https://tc39.es/proposal-regex-escaping/
+     */
+    escape(str: string): string;
+}

package/dist/_std-ext/string.d.ts

@@ -0,0 +1,4 @@
+declare interface String {
+    toCapitalized<S extends string = string>(this: S): Capitalize<S>;
+    toUncapitalized<S extends string = string>(this: S): Uncapitalize<S>;
+}

package/dist/_std-ext/symbol.d.ts

@@ -0,0 +1,14 @@
+interface SymbolConstructor {
+    /**
+     * @summary Has `symbol` factory function
+     * @template Symb Symbol type for checks
+     * @template R Symbol field type
+     * @param resultTemplate Type-only argument to infer `R` template (not used at runtime)
+     * @return Function for check and cast symbol in object
+     */
+    Has<Symb extends symbol, R = unknown>(symb: Symb, resultTemplate?: R): {
+        (obj: unknown): obj is {
+            [K in Symb]: R;
+        };
+    };
+}

package/dist/index.d.ts

@@ -1,2 +1 @@
-import './array';
-import './string';
+import './_std-ext';

package/dist/index.js

@@ -1,6 +1,38 @@
 'use strict';
 
-Object.defineProperties(Array.prototype, {
+if (!Object.definePropertyOnce)
+    Object.defineProperty(Object, 'definePropertyOnce', {
+        value(o, p, attributes) {
+            if (!(p in o))
+                Object.defineProperty(o, p, attributes);
+            return o;
+        },
+        writable: false,
+        configurable: true
+    });
+if (!Object.definePropertiesOnce)
+    Object.defineProperty(Object, 'definePropertiesOnce', {
+        value(o, properties) {
+            for (const p in properties)
+                if (!(p in o))
+                    Object.defineProperty(o, p, properties[p]);
+            return o;
+        },
+        writable: false,
+        configurable: true
+    });
+
+Object.definePropertiesOnce(Symbol, {
+    Has: {
+        value(symb) {
+            return (obj) => obj != null && symb in Object(obj);
+        },
+        writable: false,
+        configurable: true
+    }
+});
+
+Object.definePropertiesOnce(Array.prototype, {
     pack: {
         value() {
             return this && this.filter((item) => item);
@@ -13,14 +45,26 @@ Object.defineProperties(Array.prototype, {
     }
 });
 
-Object.defineProperty(String.prototype, 'toCapitalized', {
-    value() {
-        return this && this.charAt(0).toLocaleUpperCase() + this.slice(1);
+Object.definePropertiesOnce(String.prototype, {
+    toCapitalized: {
+        value() {
+            return this && this.charAt(0).toLocaleUpperCase() + this.slice(1);
+        }
+    },
+    toUncapitalized: {
+        value() {
+            return this && this.charAt(0).toLocaleLowerCase() + this.slice(1);
+        }
     }
 });
-Object.defineProperty(String.prototype, 'toUncapitalized', {
-    value() {
-        return this && this.charAt(0).toLocaleLowerCase() + this.slice(1);
+
+Object.definePropertiesOnce(RegExp, {
+    escape: {
+        value(str) {
+            return str.replace(/[\\^$.*+?()[\]{}|]/g, '\\$&');
+        },
+        writable: false,
+        configurable: true
     }
 });
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../src/array.ts","../src/string.ts"],"sourcesContent":["namespace AVStantso.Array {\n  /**\n   * @summary Select `Array<T>` or `ReadonlyArray<T>` by `[W]ritable`\n   */\n  export type RW<W extends boolean, T = unknown> = W extends true\n    ? Array<T>\n    : ReadonlyArray<T>;\n\n  /**\n   * @summary Key of `AVStantso.Array.RW<W>`\n   */\n  export type Key<W extends boolean> = keyof {\n    [K in keyof RW<W> as `${Extract<K, string>}`]: 0;\n  };\n\n  export namespace Key {\n    /**\n     * @summary Immutable array key\n     */\n    export type R = Key<false>;\n\n    /**\n     * @summary Mutable array key\n     */\n    export type RW = Key<true>;\n\n    /**\n     * @summary Mutation key only\n     */\n    export type W = Exclude<RW, R>;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  export interface Ex<W extends boolean, T> {\n    /**\n     * @summary Filter all not `falsy` items\n     * @returns New array with all not `falsy` items\n     */\n    pack(): Array<T>;\n\n    /**\n     * @summary Get last item. Array not changes\n     * @returns Last item or `undefined`, if array empty. Array not changes\n     */\n    peek(): T;\n  }\n}\n\n// eslint-disable-next-line @typescript-eslint/no-empty-object-type\ndeclare interface ReadonlyArray<T> extends AVStantso.Array.Ex<false, T> { }\n// eslint-disable-next-line @typescript-eslint/no-empty-object-type\ndeclare interface Array<T> extends AVStantso.Array.Ex<true, T> { }\n\nObject.defineProperties(Array.prototype, {\n  pack: {\n    value() {\n      return this && this.filter((item: unknown) => item);\n    }\n  },\n  peek: {\n    value() {\n      return this && this.at(-1);\n    }\n  }\n});\n","// eslint-disable-next-line @typescript-eslint/no-unused-vars\ndeclare interface String {\n  toCapitalized(): Capitalize<string>;\n  toUncapitalized(): Uncapitalize<string>;\n}\n\nObject.defineProperty(String.prototype, 'toCapitalized', {\n  value() {\n    return this && this.charAt(0).toLocaleUpperCase() + this.slice(1);\n  }\n});\n\nObject.defineProperty(String.prototype, 'toUncapitalized', {\n  value() {\n    return this && this.charAt(0).toLocaleLowerCase() + this.slice(1);\n  }\n});\n"],"names":[],"mappings":";;AAqDA,MAAM,CAAC,gBAAgB,CAAC,KAAK,CAAC,SAAS,EAAE;AACvC,IAAA,IAAI,EAAE;QACJ,KAAK,GAAA;AACH,YAAA,OAAO,IAAI,IAAI,IAAI,CAAC,MAAM,CAAC,CAAC,IAAa,KAAK,IAAI,CAAC;QACrD;AACD,KAAA;AACD,IAAA,IAAI,EAAE;QACJ,KAAK,GAAA;YACH,OAAO,IAAI,IAAI,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC;QAC5B;AACD;AACF,CAAA,CAAC;;AC1DF,MAAM,CAAC,cAAc,CAAC,MAAM,CAAC,SAAS,EAAE,eAAe,EAAE;IACvD,KAAK,GAAA;AACH,QAAA,OAAO,IAAI,IAAI,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,iBAAiB,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;IACnE;AACD,CAAA,CAAC;AAEF,MAAM,CAAC,cAAc,CAAC,MAAM,CAAC,SAAS,EAAE,iBAAiB,EAAE;IACzD,KAAK,GAAA;AACH,QAAA,OAAO,IAAI,IAAI,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,iBAAiB,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;IACnE;AACD,CAAA,CAAC;;"}
+{"version":3,"file":"index.js","sources":["../src/_std-ext/object.ts","../src/_std-ext/symbol.ts","../src/_std-ext/array.ts","../src/_std-ext/string.ts","../src/_std-ext/reg-exp.ts"],"sourcesContent":["// eslint-disable-next-line @typescript-eslint/no-unused-vars\ninterface ObjectConstructor {\n  /**\n   * Adds a property to an object (if it's not exists).\n   * @param o Object on which to add the property.\\\n   * This can be a native JavaScript object (that is, a user-defined object or a built in object) or a DOM object.\n   * @param p The property name.\n   * @param attributes Descriptor for the property. It can be for a data property or an accessor property.\n   */\n  definePropertyOnce: ObjectConstructor['defineProperty'];\n\n  /**\n   * Adds one or more properties to an object (if it's not exists).\n   * @param o Object on which to add or modify the properties. This can be a native JavaScript object or a DOM object.\n   * @param properties JavaScript object that contains one or more descriptor objects.\\\n   * Each descriptor object describes a data property or an accessor property.\n  */\n  definePropertiesOnce: ObjectConstructor['defineProperties'];\n}\n\nif (!Object.definePropertyOnce)\n  Object.defineProperty(Object, 'definePropertyOnce', {\n    value<T>(o: T, p: PropertyKey, attributes: PropertyDescriptor): T {\n      if (!(p in (o as object))) Object.defineProperty(o, p, attributes);\n      return o;\n    },\n    writable: false,\n    configurable: true\n  });\n\nif (!Object.definePropertiesOnce)\n  Object.defineProperty(Object, 'definePropertiesOnce', {\n    value<T>(o: T, properties: PropertyDescriptorMap): T {\n      for (const p in properties)\n        if (!(p in (o as object))) Object.defineProperty(o, p, properties[p]);\n      return o;\n    },\n    writable: false,\n    configurable: true\n  });\n","// eslint-disable-next-line @typescript-eslint/no-unused-vars\ninterface SymbolConstructor {\n  /**\n   * @summary Has `symbol` factory function\n   * @template Symb Symbol type for checks\n   * @template R Symbol field type\n   * @param resultTemplate Type-only argument to infer `R` template (not used at runtime)\n   * @return Function for check and cast symbol in object\n   */\n  Has<\n    Symb extends symbol,\n    R = unknown\n  >(symb: Symb, resultTemplate?: R): {\n    (obj: unknown): obj is { [K in Symb]: R };\n  }\n}\n\nObject.definePropertiesOnce(Symbol, {\n  Has: {\n    value(symb: symbol) {\n      return (obj: unknown) => obj != null && symb in Object(obj);\n    },\n    writable: false,\n    configurable: true\n  }\n});\n","namespace AVStantso.Array {\n  /**\n   * @summary Select `Array<T>` or `ReadonlyArray<T>` by `[W]ritable`\n   */\n  export type RW<W extends boolean, T = unknown> = W extends true\n    ? Array<T>\n    : ReadonlyArray<T>;\n\n  /**\n   * @summary Key of `AVStantso.Array.RW<W>`\n   */\n  export type Key<W extends boolean> = keyof {\n    [K in keyof RW<W> as `${Extract<K, string>}`]: 0;\n  };\n\n  export namespace Key {\n    /**\n     * @summary Immutable array key\n     */\n    export type R = Key<false>;\n\n    /**\n     * @summary Mutable array key\n     */\n    export type RW = Key<true>;\n\n    /**\n     * @summary Mutation key only\n     */\n    export type W = Exclude<RW, R>;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  export interface Ex<W extends boolean, T> {\n    /**\n     * @summary Filter all not `falsy` items\n     * @returns New array with all not `falsy` items\n     */\n    pack(): Array<T>;\n\n    /**\n     * @summary Get last item. Array not changes\n     * @returns Last item or `undefined`, if array empty. Array not changes\n     */\n    peek(): T;\n  }\n}\n\n// eslint-disable-next-line @typescript-eslint/no-empty-object-type\ndeclare interface ReadonlyArray<T> extends AVStantso.Array.Ex<false, T> { }\n// eslint-disable-next-line @typescript-eslint/no-empty-object-type\ndeclare interface Array<T> extends AVStantso.Array.Ex<true, T> { }\n\nObject.definePropertiesOnce(Array.prototype, {\n  pack: {\n    value() {\n      return this && this.filter((item: unknown) => item);\n    }\n  },\n  peek: {\n    value() {\n      return this && this.at(-1);\n    }\n  }\n});\n","// eslint-disable-next-line @typescript-eslint/no-unused-vars\ndeclare interface String {\n  toCapitalized<S extends string = string>(this: S): Capitalize<S>;\n  toUncapitalized<S extends string = string>(this: S): Uncapitalize<S>;\n}\n\nObject.definePropertiesOnce(String.prototype, {\n  toCapitalized: {\n    value() {\n      return this && this.charAt(0).toLocaleUpperCase() + this.slice(1);\n    }\n  },\n  toUncapitalized: {\n    value() {\n      return this && this.charAt(0).toLocaleLowerCase() + this.slice(1);\n    }\n  }\n});\n","// eslint-disable-next-line @typescript-eslint/no-unused-vars\ninterface RegExpConstructor {\n  /**\n   * @summary Escape all `RegExp` special characters in a string\n   * @returns New string with escaped `RegExp` characters\n   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/escape\n   * @see https://tc39.es/proposal-regex-escaping/\n   */\n  escape(str: string): string;\n}\n\nObject.definePropertiesOnce(RegExp, {\n  escape: {\n    value(str: string) {\n      return str.replace(/[\\\\^$.*+?()[\\]{}|]/g, '\\\\$&');\n    },\n    writable: false,\n    configurable: true\n  }\n});\n"],"names":[],"mappings":";;AAoBA,IAAI,CAAC,MAAM,CAAC,kBAAkB;AAC5B,IAAA,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,oBAAoB,EAAE;AAClD,QAAA,KAAK,CAAI,CAAI,EAAE,CAAc,EAAE,UAA8B,EAAA;AAC3D,YAAA,IAAI,EAAE,CAAC,IAAK,CAAY,CAAC;gBAAE,MAAM,CAAC,cAAc,CAAC,CAAC,EAAE,CAAC,EAAE,UAAU,CAAC;AAClE,YAAA,OAAO,CAAC;QACV,CAAC;AACD,QAAA,QAAQ,EAAE,KAAK;AACf,QAAA,YAAY,EAAE;AACf,KAAA,CAAC;AAEJ,IAAI,CAAC,MAAM,CAAC,oBAAoB;AAC9B,IAAA,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,sBAAsB,EAAE;QACpD,KAAK,CAAI,CAAI,EAAE,UAAiC,EAAA;YAC9C,KAAK,MAAM,CAAC,IAAI,UAAU;AACxB,gBAAA,IAAI,EAAE,CAAC,IAAK,CAAY,CAAC;AAAE,oBAAA,MAAM,CAAC,cAAc,CAAC,CAAC,EAAE,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC;AACvE,YAAA,OAAO,CAAC;QACV,CAAC;AACD,QAAA,QAAQ,EAAE,KAAK;AACf,QAAA,YAAY,EAAE;AACf,KAAA,CAAC;;ACtBJ,MAAM,CAAC,oBAAoB,CAAC,MAAM,EAAE;AAClC,IAAA,GAAG,EAAE;AACH,QAAA,KAAK,CAAC,IAAY,EAAA;AAChB,YAAA,OAAO,CAAC,GAAY,KAAK,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,MAAM,CAAC,GAAG,CAAC;QAC7D,CAAC;AACD,QAAA,QAAQ,EAAE,KAAK;AACf,QAAA,YAAY,EAAE;AACf;AACF,CAAA,CAAC;;AC4BF,MAAM,CAAC,oBAAoB,CAAC,KAAK,CAAC,SAAS,EAAE;AAC3C,IAAA,IAAI,EAAE;QACJ,KAAK,GAAA;AACH,YAAA,OAAO,IAAI,IAAI,IAAI,CAAC,MAAM,CAAC,CAAC,IAAa,KAAK,IAAI,CAAC;QACrD;AACD,KAAA;AACD,IAAA,IAAI,EAAE;QACJ,KAAK,GAAA;YACH,OAAO,IAAI,IAAI,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC;QAC5B;AACD;AACF,CAAA,CAAC;;AC1DF,MAAM,CAAC,oBAAoB,CAAC,MAAM,CAAC,SAAS,EAAE;AAC5C,IAAA,aAAa,EAAE;QACb,KAAK,GAAA;AACH,YAAA,OAAO,IAAI,IAAI,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,iBAAiB,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;QACnE;AACD,KAAA;AACD,IAAA,eAAe,EAAE;QACf,KAAK,GAAA;AACH,YAAA,OAAO,IAAI,IAAI,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,iBAAiB,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;QACnE;AACD;AACF,CAAA,CAAC;;ACNF,MAAM,CAAC,oBAAoB,CAAC,MAAM,EAAE;AAClC,IAAA,MAAM,EAAE;AACN,QAAA,KAAK,CAAC,GAAW,EAAA;YACf,OAAO,GAAG,CAAC,OAAO,CAAC,qBAAqB,EAAE,MAAM,CAAC;QACnD,CAAC;AACD,QAAA,QAAQ,EAAE,KAAK;AACf,QAAA,YAAY,EAAE;AACf;AACF,CAAA,CAAC;;"}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@avstantso/std-ext",
   "license": "MIT",
   "author": "avstantso",
-  "version": "1.0.2",
+  "version": "1.2.1",
   "description": "Standard JS objects extension. Zero-dependencies",
   "keywords": [
     "String",

package/dist/string.d.ts

@@ -1,4 +0,0 @@
-declare interface String {
-    toCapitalized(): Capitalize<string>;
-    toUncapitalized(): Uncapitalize<string>;
-}