@arkyn/shared 3.0.1-beta.99 → 3.0.3

package/README.md

@@ -1,123 +1,152 @@
 # @arkyn/shared
 
-A comprehensive collection of reusable utilities for consistent data handling across your applications. Provides formatting functions, validation tools, generators, and services to streamline common development tasks.
+Comprehensive collection of reusable utilities for data formatting, validation, generation, and manipulation, featuring Brazilian document validators and financial tools.
 
 [![npm version](https://img.shields.io/npm/v/@arkyn/shared.svg)](https://www.npmjs.com/package/@arkyn/shared)
 [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
 [![TypeScript](https://img.shields.io/badge/TypeScript-Ready-blue.svg)](https://www.typescriptlang.org/)
 
+## 🎯 What it solves
+
+`@arkyn/shared` is a dependency-light, framework-agnostic toolkit for formatting, validating, generating, and parsing common data types in JavaScript/TypeScript applications. It has strong support for Brazilian documents (CPF, CNPJ, CEP) and locale-aware financial formatting, alongside general-purpose helpers for dates, JSON, strings, IDs, and sensitive-data masking. Because it has no framework assumptions, the same functions run identically on the client and the server — it's the shared foundation used by both `@arkyn/components` and `@arkyn/server`.
+
 ## ✨ Features
 
-- 📅 **Date Utilities** - Flexible date manipulation and timezone support
-- 🏦 **Financial Tools** - Currency formatting and installment calculations
-- 🔒 **Brazilian Validators** - CPF, CNPJ, CEP, RG, and phone number validation
-- 🎨 **String Utilities** - Formatting, masking, and text manipulation
-- 🔧 **Generators** - ID generation, slugs, colors, and more
-- 🛡️ **Data Security** - Sensitive data masking and sanitization
-- 🌐 **Internationalization** - Multi-locale support for formatting
+- 📅 **Date formatting & parsing** — configurable input/output formats with timezone shifting
+- 💰 **Currency & financial formatting** — locale-aware currency strings and card installment math
+- 📝 **Text formatting** — capitalization, ellipsis truncation, digit masking
+- 🇧🇷 **Brazilian document formatting** — CPF, CNPJ, CEP
+- 📞 **Phone formatting** — country-mask-aware phone number formatting via `libphonenumber-js`
+- 🔧 **Generators** — UUID (v4/v7) IDs, URL-friendly slugs, deterministic colors from strings
+- 🧩 **JSON parsers** — pretty-printing, large-field truncation, sensitive-key masking
+- 🛡️ **Sensitive-data masking** — hide digits/fields in strings and JSON payloads
+- 🌐 **HTML utilities** — detect and strip HTML markup
+- 🧹 **String/number utilities** — strip non-numeric characters, strip currency symbols, ensure quoting
+
+## 📋 Prerequisites
+
+- **Node.js** `>=18.0.0`
+- **Bun** `>=1.0.0`
+- **`libphonenumber-js`** `>=1.13.7` — optional peer dependency, required only if you use `formatToPhone` or `findCountryMask`
 
 ## 📦 Installation
 
+> **ESM only.** This package ships as native ES modules with no CommonJS build — use `import`, not `require()`.
+
 ```bash
 npm install @arkyn/shared
 ```
 
+If you plan to use `formatToPhone` or `findCountryMask`, also install the peer dependency:
+
+```bash
+npm install libphonenumber-js
+```
+
 ## 🚀 Quick Start
 
 ```typescript
 import {
   formatToCpf,
-  validateCpf,
   formatToCurrency,
   generateId,
+  generateSlug,
 } from "@arkyn/shared";
 
-// Format and validate CPF
-const cpf = formatToCpf("12345678901"); // "123.456.789-01"
-const isValid = validateCpf(cpf); // true
+// Format a raw CPF string (throws if it doesn't have 11 digits)
+const cpf = formatToCpf("12345678909");
+// "123.456.789-09"
 
-// Format currency
-const price = formatToCurrency(1299.99); // "R$ 1.299,99"
+// Format currency using a currency code from @arkyn/templates
+const price = formatToCurrency(1234.56, "BRL");
+// "R$ 1.234,56"
 
-// Generate unique ID
-const id = generateId(); // "uuid-v4-string"
+// Generate a UUID v4
+const id = generateId("text", "v4");
+// "550e8400-e29b-41d4-a716-446655440000"
+
+// Generate a URL-friendly slug
+const slug = generateSlug("Hello, World! This is a Test.");
+// "hello-world-this-is-a-test"
 ```
 
-## 📋 API Reference
+## 📖 API Reference
 
-### 📅 Date Formatting
+### Formats
 
-#### formatDate(date, inputFormat, outputFormat, timezone?)
+#### formatDate
 
-Formats dates with timezone support.
+Formats a date (and optional time) string into a custom output format. Calculations are done in UTC+0; use the `timezone` parameter to shift the result. Throws `Error` if the resulting date is invalid or `inputFormat` is not recognized.
 
 ```typescript
 import { formatDate } from "@arkyn/shared";
 
-// Format ISO date to Brazilian format
-const formatted = formatDate("2023-12-25", "isoDate", "DD/MM/YYYY");
-// Result: "25/12/2023"
-
-// With timezone
-const withTz = formatDate(
-  "2023-12-25T10:00:00Z",
-  "isoDate",
-  "DD/MM/YYYY HH:mm",
-  -3
-);
-// Result: "25/12/2023 07:00"
+formatDate(["25/12/2023", "15:30:00"], "brazilianDate", "YYYY-MM-DD hh:mm");
+// "2023-12-25 15:30"
+
+formatDate(["2023-12-25", "15:30:00"], "timestamp", "DD/MM/YYYY hh:mm", -3);
+// "2023-12-25 12:30"
 ```
 
-#### formatToDate(date, inputFormat, timezone?)
+#### formatJsonObject
 
-Converts strings to Date objects.
+Formats a JSON-compatible value (object, array, string, or primitive) into a human-readable, indented string. Strings that parse as JSON are recursively formatted.
 
 ```typescript
-import { formatToDate } from "@arkyn/shared";
+import { formatJsonObject } from "@arkyn/shared";
 
-const date = formatToDate("25/12/2023", "brazilianDate");
-// Result: Date object
+const obj = { name: "John", age: 30, hobbies: ["reading", "gaming"] };
+formatJsonObject(obj, 0);
+// {
+//   "name": "John",
+//   "age": 30,
+//   "hobbies": [
+//     "reading",
+//     "gaming"
+//   ]
+// }
 ```
 
-### 🏦 Financial Formatting
-
-#### formatToCurrency(value: number): string
+#### formatJsonString
 
-Formats numbers to Brazilian currency format.
+Parses a JSON string and returns a pretty-printed representation. Throws `Error` if the input is not valid JSON.
 
 ```typescript
-import { formatToCurrency } from "@arkyn/shared";
+import { formatJsonString } from "@arkyn/shared";
 
-formatToCurrency(1299.99); // "R$ 1.299,99"
-formatToCurrency(0.5); // "R$ 0,50"
+formatJsonString('{"name":"John","hobbies":["reading","gaming"]}');
+// {
+//   "name": "John",
+//   "hobbies": [
+//     "reading",
+//     "gaming"
+//   ]
+// }
 ```
 
-#### calculateCardInstallment(total: number, installments: number): number[]
+#### formatToCapitalizeFirstWordLetter
 
-Calculates installment values for credit card payments.
+Capitalizes the first letter of each space-separated word and lowercases the rest.
 
 ```typescript
-import { calculateCardInstallment } from "@arkyn/shared";
+import { formatToCapitalizeFirstWordLetter } from "@arkyn/shared";
 
-const installments = calculateCardInstallment(1000, 10);
-// Result: [100, 100, 100, 100, 100, 100, 100, 100, 100, 100]
+formatToCapitalizeFirstWordLetter("HELLO WORLD"); // "Hello World"
 ```
 
-### 🇧🇷 Brazilian Document Formatting
-
-#### formatToCpf(value: string): string
+#### formatToCep
 
-Formats strings to CPF format.
+Formats a string into the Brazilian postal code (CEP) pattern `XXXXX-XXX`. Throws `Error` if the cleaned input doesn't contain exactly 8 numeric digits.
 
 ```typescript
-import { formatToCpf } from "@arkyn/shared";
+import { formatToCep } from "@arkyn/shared";
 
-formatToCpf("12345678901"); // "123.456.789-01"
+formatToCep("12345678"); // "12345-678"
 ```
 
-#### formatToCnpj(value: string): string
+#### formatToCnpj
 
-Formats strings to CNPJ format.
+Formats a string into the CNPJ pattern `XX.XXX.XXX/XXXX-XX`. Throws `Error` if the cleaned input doesn't contain exactly 14 numeric digits.
 
 ```typescript
 import { formatToCnpj } from "@arkyn/shared";
@@ -125,380 +154,241 @@ import { formatToCnpj } from "@arkyn/shared";
 formatToCnpj("12345678000195"); // "12.345.678/0001-95"
 ```
 
-#### formatToCpfCnpj(value: string): string
+#### formatToCpf
 
-Auto-detects and formats CPF or CNPJ.
+Formats a string into the CPF pattern `XXX.XXX.XXX-XX`. Throws `Error` if the cleaned input doesn't contain exactly 11 numeric digits.
 
 ```typescript
-import { formatToCpfCnpj } from "@arkyn/shared";
-
-formatToCpfCnpj("12345678901"); // "123.456.789-01" (CPF)
-formatToCpfCnpj("12345678000195"); // "12.345.678/0001-95" (CNPJ)
-```
-
-#### formatToCep(value: string): string
-
-Formats strings to CEP format.
-
-```typescript
-import { formatToCep } from "@arkyn/shared";
+import { formatToCpf } from "@arkyn/shared";
 
-formatToCep("01234567"); // "01234-567"
+formatToCpf("12345678909"); // "123.456.789-09"
 ```
 
-#### formatToPhone(value: string): string
+#### formatToCurrency
 
-Formats phone numbers.
+Formats a number into a locale-aware currency string using `Intl.NumberFormat`, based on a currency code from `@arkyn/templates`. Set `config.showPrefix` to `false` to omit the currency symbol. Throws `Error` for unsupported currency codes.
 
 ```typescript
-import { formatToPhone } from "@arkyn/shared";
+import { formatToCurrency } from "@arkyn/shared";
 
-formatToPhone("11987654321"); // "(11) 98765-4321"
+formatToCurrency(1234.56, "BRL"); // "R$ 1.234,56"
+formatToCurrency(1234.56, "USD", { showPrefix: false }); // "1,234.56"
 ```
 
----
-
-### 🎨 String Utilities
+#### formatToEllipsis
 
-#### formatToEllipsis(value: string, maxLength: number): string
-
-Truncates strings with ellipsis.
+Truncates a string to `maxLength`, avoiding breaking mid-word, and appends `"..."` if truncation occurred.
 
 ```typescript
 import { formatToEllipsis } from "@arkyn/shared";
 
-formatToEllipsis("This is a very long text", 10); // "This is a..."
+formatToEllipsis("Hello, world!", 5); // "Hello..."
 ```
 
-#### formatToHiddenDigits(value: string): string
+#### formatToHiddenDigits
 
-Masks sensitive information.
+Replaces specific digit positions in a string with a masking character, leaving non-digit characters unchanged. `options.range` can be a positive number (first N digits), a negative number (last N digits), or a `[start, end]` tuple (1-indexed, inclusive). Defaults to hiding the first 3 digits with `"*"`.
 
 ```typescript
 import { formatToHiddenDigits } from "@arkyn/shared";
 
-formatToHiddenDigits("123456789"); // "12***6789"
+formatToHiddenDigits("123-456-7890", { range: 3 }); // "***-456-7890"
+formatToHiddenDigits("123-456-7890", { range: [4, 6], hider: "#" });
+// "123-###-7890"
 ```
 
-#### formatToCapitalizeFirstWordLetter(value: string): string
+#### formatToPhone
 
-Capitalizes the first letter of each word.
+Formats a phone number according to the country mask defined in `@arkyn/templates`, parsing it with `libphonenumber-js`. Throws `Error` if the number is invalid or no country mask is found. Requires the `libphonenumber-js` peer dependency.
 
 ```typescript
-import { formatToCapitalizeFirstWordLetter } from "@arkyn/shared";
-
-formatToCapitalizeFirstWordLetter("hello world"); // "Hello World"
-```
-
-#### stripHtmlTags(value: string): string
-
-Removes HTML tags from strings.
-
-```typescript
-import { stripHtmlTags } from "@arkyn/shared";
+import { formatToPhone } from "@arkyn/shared";
 
-stripHtmlTags("<p>Hello <strong>World</strong></p>"); // "Hello World"
+formatToPhone("+5534920524282"); // "(34) 92052-4282"
+formatToPhone("+12125550199"); // "(212) 555-0199"
 ```
 
-### 📄 JSON Utilities
+### Generators
 
-#### formatJsonObject(obj: object): string
+#### generateColorByString
 
-Converts objects to formatted JSON strings.
+Generates a deterministic hexadecimal color code from a hash of the input string — the same input always produces the same color.
 
 ```typescript
-import { formatJsonObject } from "@arkyn/shared";
-
-const obj = { name: "John", age: 30 };
-formatJsonObject(obj); // Pretty-printed JSON string
-```
-
-#### formatJsonString(json: string): object
-
-Parses JSON strings safely.
-
-```typescript
-import { formatJsonString } from "@arkyn/shared";
+import { generateColorByString } from "@arkyn/shared";
 
-const parsed = formatJsonString('{"name":"John"}');
-// Result: { name: "John" }
+generateColorByString("example"); // "#5e8f9a" (consistent for the same input)
 ```
 
----
-
-### 🔧 Generators
-
-#### generateId(): string
+#### generateId
 
-Generates unique identifiers using UUID v4.
+Generates a UUID in the requested version (`"v4"` random or `"v7"` time-ordered) and representation (`"text"` string or `"binary"` `Uint8Array`). Throws `Error` for an invalid type/format combination.
 
 ```typescript
 import { generateId } from "@arkyn/shared";
 
-const id = generateId(); // "f47ac10b-58cc-4372-a567-0e02b2c3d479"
+generateId("text", "v4"); // "550e8400-e29b-41d4-a716-446655440000"
+generateId("binary", "v7"); // Uint8Array([...])
 ```
 
-#### generateSlug(value: string): string
+#### generateSlug
 
-Creates URL-friendly slugs.
+Converts a string into a URL-friendly slug: strips accents, removes non-alphanumeric characters (except spaces/hyphens), lowercases, replaces spaces with hyphens, and trims/collapses hyphens.
 
 ```typescript
 import { generateSlug } from "@arkyn/shared";
 
-generateSlug("Hello World! How are you?"); // "hello-world-how-are-you"
+generateSlug("Hello, World! This is a Test.");
+// "hello-world-this-is-a-test"
 ```
 
-#### generateColorByString(value: string): string
+### Parsers
 
-Generates consistent colors from strings.
+#### parseLargeFields
 
-```typescript
-import { generateColorByString } from "@arkyn/shared";
-
-generateColorByString("John Doe"); // "#3498db" (always same color for same input)
-```
-
-### 🛡️ Data Security & Sanitization
-
-#### maskSensitiveData(data: string): string
-
-Masks sensitive information in logs and outputs.
+Parses a JSON string and truncates string fields exceeding `maxLength` (default `1000`), replacing them with a message indicating the original length. Traverses nested objects/arrays. Throws `Error` if the input is not valid JSON.
 
 ```typescript
-import { maskSensitiveData } from "@arkyn/shared";
+import { parseLargeFields } from "@arkyn/shared";
 
-maskSensitiveData("user@email.com"); // "us***@email.com"
-```
-
-#### removeNonNumeric(value: string): string
+const json = JSON.stringify({
+  name: "John",
+  description: "A very long description that exceeds the maximum length...",
+});
 
-Removes all non-numeric characters.
-
-```typescript
-import { removeNonNumeric } from "@arkyn/shared";
-
-removeNonNumeric("(11) 98765-4321"); // "11987654321"
+parseLargeFields(json, 50);
+// '{"name":"John","description":"To large information: field as 57 characters"}'
 ```
 
-#### removeCurrencySymbols(value: string): string
+#### parseSensitiveData
 
-Removes currency symbols and formatting.
+Parses a JSON string and replaces the values of the given keys with `"****"`, recursively, including JSON-encoded string values. Defaults to masking `password`, `confirmPassword`, and `creditCard`. Returns the original string unchanged if it is not valid JSON (does not throw).
 
 ```typescript
-import { removeCurrencySymbols } from "@arkyn/shared";
+import { parseSensitiveData } from "@arkyn/shared";
 
-removeCurrencySymbols("R$ 1.299,99"); // "1299.99"
-```
-
-#### ensureQuotes(rawValue: string): string
+const jsonString = JSON.stringify({
+  username: "user123",
+  password: "secret",
+  profile: { creditCard: "1234-5678-9012-3456" },
+});
 
-Ensures strings are properly quoted.
-
-```typescript
-import { ensureQuotes } from "@arkyn/shared";
-
-ensureQuotes("hello"); // '"hello"'
-ensureQuotes('"hello"'); // '"hello"' (no double quotes)
+parseSensitiveData(jsonString, ["password", "creditCard"]);
+// '{"username":"user123","password":"****","profile":{"creditCard":"****"}}'
 ```
 
-#### truncateLargeFields(obj: object, maxLength: number): object
+#### parseToDate
 
-Truncates large text fields in objects.
+Parses a date (and optional time) string into a `Date` object. Calculations are done in UTC+0; use `timezone` to shift the result. Throws `Error` if the resulting date is invalid or `inputFormat` is not recognized.
 
 ```typescript
-import { truncateLargeFields } from "@arkyn/shared";
+import { parseToDate } from "@arkyn/shared";
 
-const data = { description: "Very long text..." };
-truncateLargeFields(data, 10); // { description: 'Very long...' }
-```
+parseToDate(["25/12/2023", "15:30:00"], "brazilianDate", -3);
+// Date: 2023-12-25T12:30:00.000Z
 
----
+parseToDate(["2023-12-25"], "timestamp");
+// Date: 2023-12-25T00:00:00.000Z
+```
 
-### ✅ Validation Functions
+### Services
 
-#### validateCpf(value: string): boolean
+#### ValidateDateService
 
-Validates Brazilian CPF numbers.
+Class used internally by `formatDate` and `parseToDate` to validate date components and input-format strings — enforces 4-digit years, month/day ranges, month-specific day counts, and leap-year rules. `validateDateParts` and `validateInputFormat` both throw `Error` on invalid input.
 
 ```typescript
-import { validateCpf } from "@arkyn/shared";
+import { ValidateDateService } from "@arkyn/shared";
 
-validateCpf("123.456.789-01"); // true/false
-validateCpf("12345678901"); // true/false (accepts without formatting)
+const service = new ValidateDateService();
+service.validateDateParts(2024, 2, 29); // OK — leap year
+service.validateDateParts(2023, 2, 29); // throws — not a leap year
+service.validateInputFormat("brazilianDate"); // OK
+service.validateInputFormat("custom"); // throws
 ```
 
-#### validateCnpj(value: string): boolean
-
-Validates Brazilian CNPJ numbers.
-
-```typescript
-import { validateCnpj } from "@arkyn/shared";
-
-validateCnpj("12.345.678/0001-95"); // true/false
-```
+### Utilities
 
-#### validateCep(value: string): boolean
+#### calculateCardInstallment
 
-Validates Brazilian postal codes.
+Calculates the total price and per-installment price for a card payment plan with compound interest. No interest is applied when `fees` is `0` or `numberInstallments` is `1`. Throws `Error` if `numberInstallments <= 0` or `fees < 0`.
 
 ```typescript
-import { validateCep } from "@arkyn/shared";
+import { calculateCardInstallment } from "@arkyn/shared";
 
-validateCep("01234-567"); // true/false
-validateCep("01234567"); // true/false (accepts without formatting)
+calculateCardInstallment({ cashPrice: 1000, numberInstallments: 12, fees: 0.02 });
+// { totalPrice: 1124.62, installmentPrice: 93.72 }
 ```
 
-#### validatePhone(value: string): boolean
+#### ensureQuotes
 
-Validates Brazilian phone numbers.
+Wraps a string in double quotes unless it is already enclosed in single or double quotes.
 
 ```typescript
-import { validatePhone } from "@arkyn/shared";
+import { ensureQuotes } from "@arkyn/shared";
 
-validatePhone("(11) 98765-4321"); // true/false
-validatePhone("11987654321"); // true/false
+ensureQuotes("example"); // '"example"'
+ensureQuotes('"already quoted"'); // '"already quoted"'
 ```
 
-#### validateRg(value: string): boolean
+#### findCountryMask
 
-Validates Brazilian RG (ID) numbers.
+Resolves the matching phone mask (using `"_"` as digit placeholders) and country metadata for an E.164 phone number, using `libphonenumber-js` and `@arkyn/templates`. For countries with multiple mask lengths (e.g. Brazil with/without the ninth digit), the mask matching the number's digit count is returned. Throws `Error` if the number is invalid or no mask is found. Requires the `libphonenumber-js` peer dependency.
 
 ```typescript
-import { validateRg } from "@arkyn/shared";
+import { findCountryMask } from "@arkyn/shared";
 
-validateRg("12.345.678-9"); // true/false
+const [mask, country] = findCountryMask("+5511999999999");
+// mask: "(__) _____-____"
+// country.name: "Brazil"
 ```
 
-#### validateDate(value: string): boolean
+#### isHtml
 
-Validates date strings.
+Checks whether a string contains HTML markup (opening or closing tags), case-insensitively.
 
 ```typescript
-import { validateDate } from "@arkyn/shared";
+import { isHtml } from "@arkyn/shared";
 
-validateDate("25/12/2023"); // true/false
-validateDate("2023-12-25"); // true/false
+isHtml("<p>Hello world</p>"); // true
+isHtml("Plain text"); // false
 ```
 
-#### validatePassword(value: string): boolean
+#### removeCurrencySymbols
 
-Validates password strength.
+Removes currency symbols (`R$`, `$`, `€`, `¥`, `£`, and other Unicode currency symbols) from a string and trims whitespace.
 
 ```typescript
-import { validatePassword } from "@arkyn/shared";
+import { removeCurrencySymbols } from "@arkyn/shared";
 
-validatePassword("MyPassword123!"); // true/false
+removeCurrencySymbols("R$13,45"); // "13,45"
+removeCurrencySymbols("€99.99"); // "99.99"
 ```
 
-## 🔧 Advanced Usage
+#### removeNonNumeric
 
-### Complete Form Validation
+Strips all non-numeric characters from a string.
 
 ```typescript
-import {
-  validateCpf,
-  validatePhone,
-  validateCep,
-  formatToCpf,
-  formatToPhone,
-  formatToCep,
-} from "@arkyn/shared";
-
-function validateUserForm(data) {
-  const errors = {};
-
-  // Validate and format CPF
-  if (!validateCpf(data.cpf)) {
-    errors.cpf = "Invalid CPF";
-  } else {
-    data.cpf = formatToCpf(data.cpf);
-  }
-
-  // Validate and format phone
-  if (!validatePhone(data.phone)) {
-    errors.phone = "Invalid phone number";
-  } else {
-    data.phone = formatToPhone(data.phone);
-  }
-
-  // Validate and format CEP
-  if (!validateCep(data.cep)) {
-    errors.cep = "Invalid postal code";
-  } else {
-    data.cep = formatToCep(data.cep);
-  }
-
-  return { isValid: Object.keys(errors).length === 0, errors, data };
-}
-```
-
-### Data Processing Pipeline
-
-```typescript
-import {
-  removeNonNumeric,
-  formatToCurrency,
-  calculateCardInstallment,
-  generateId,
-} from "@arkyn/shared";
+import { removeNonNumeric } from "@arkyn/shared";
 
-function processOrder(orderData) {
-  // Clean price input
-  const numericPrice = removeNonNumeric(orderData.price);
-  const price = parseFloat(numericPrice) / 100; // Convert cents to reais
-
-  // Format for display
-  const formattedPrice = formatToCurrency(price);
-
-  // Calculate installments
-  const installments = calculateCardInstallment(price, 12);
-
-  // Generate order ID
-  const orderId = generateId();
-
-  return {
-    id: orderId,
-    price: formattedPrice,
-    installmentOptions: installments.map((value, index) => ({
-      number: index + 1,
-      value: formatToCurrency(value),
-    })),
-  };
-}
+removeNonNumeric("abc123def456"); // "123456"
 ```
 
-## 🧪 Development
+#### stripHtmlTags
 
-```bash
-# Install dependencies
-bun install
+Removes HTML tags from a string, including `<script>` and `<style>` blocks and HTML comments.
 
-# Build the package
-bun run build
-
-# Run tests
-bun run test
+```typescript
+import { stripHtmlTags } from "@arkyn/shared";
 
-# Type check
-bun run typecheck
+stripHtmlTags("<p>Hello <strong>World</strong></p>"); // "Hello World"
 ```
 
----
-
-## 🤝 Contributing
+## 📚 Documentation
 
-Contributions are welcome! Please read our contributing guidelines and submit pull requests to help improve the package.
+Full documentation: [https://docs.arkyn.dev/docs/shared/introduction](https://docs.arkyn.dev/docs/shared/introduction)
 
 ## 📄 License
 
 This project is licensed under the Apache 2.0 License - see the [LICENSE](./LICENSE.txt) file for details.
-
-## 🔗 Links
-
-- [GitHub Repository](https://github.com/Lucas-Eduardo-Goncalves/arkyn)
-- [NPM Package](https://www.npmjs.com/package/@arkyn/shared)
-- [Full Documentation](https://github.com/Lucas-Eduardo-Goncalves/arkyn#readme)
-
----
-
-Made with ❤️ by the Arkyn team