@danielhaim/titlecaser 1.2.23

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Daniel Haim
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,292 @@
+# TitleCaser
+
+Transform any text to proper title case format using popular style guides such as APA, AP, Chicago, NYT, Wikipedia, and British. Customize options to achieve greater flexibility and consistency.
+
+## Demo
+
+<a target="_blank" href="https://danielhaim1.github.io/titlecaser/"><img src="dist/demo.png" width="100%" height="auto"></a>
+
+[![npm version](https://badge.fury.io/js/titlecaser.svg?t=1623701119)](https://badge.fury.io/js/titlecaser)
+[![Downloads](https://img.shields.io/npm/dt/titlecaser.svg)](https://www.npmjs.com/package/titlecaser)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+The Language Conventions and Style Module is a comprehensive library designed to help web content developers adhere to the latest style guides and English language conventions. It offers a wide range of features, including support for various style guides such as AP, APA, Chicago, NY Times, Wikipedia, and British styles, and customizable preferences to suit your specific needs.
+
+To streamline workflow, the Language Conventions and Style Module is available in both browser and node environment versions and includes a command-line interface for building, testing, and minimizing the module. Additionally, it features a filter ability that allows users to ignore certain phrases containing short words, preventing the module from mistakenly flagging instances where short words are used as part of a larger term or phrase.
+
+The module has been designed to handle various capitalization scenarios, including hyphenated words, prefixes, suffixes, reserved words, Roman numerals, proper nouns that contain lowercase letters, and words that require capitalization in specific contexts. This ensures that your content meets the appropriate style and formatting guidelines, regardless of the context. It also offers word replacement capabilities, as well as ignored phrases to create consistency in cases where certain terms may be capitalized differently depending on the context, such as converting variations of gOogle to Google, front-end to Frontend.
+
+So whether you're developing web content for a major news organization or simply looking to improve your writing skills, the Language Conventions and Style Module is an essential tool that can help ensure your work is accurate, consistent, and conforms to the latest style guidelines.
+
+## Key Features:
+
+- Support for popular style guides and customizable preferences
+- Advanced capitalization handling for suffixes, prefixes, hyphenated words, and reserved words
+- Support for proper capitalization of Roman numerals and exclusion of specific words and phrases from title capitalization
+- Word replacement capabilities for consistency in capitalization
+Command-line interface for building, testing, and minimizing the module
+- Pre-defined word lists for articles, conjunctions, prepositions, and uncapitalized words in titles
+- Exclusion of common phrases from title capitalization
+
+## Installation
+You can install this module via npm:
+
+```bash
+npm i @danielhaim/titlecaser
+```
+
+## Usage
+
+The package can be imported and used in both Node.js and browser environments using the following syntax:
+
+```js
+// CommonJS
+const { TitleCaser } = require('./path/to/titlecaser');
+const TitleCaser = require('./path/to/titlecaser');
+
+// ECMAScript
+import { TitleCaser } from './TitleCaser';
+```
+
+Here's an example of how to use the modulate function:
+
+```js
+const options = {
+        style: 'chicago'
+      };
+
+const titleCaser = new TitleCaser(options);
+
+const input = 'the book   of     life';
+const output = titleCaser.toTitleCase(input);
+
+console.log(output); // 'The Book of Life'
+```
+
+## Usage in the Browser
+
+The function can also be used in a browser environment by including the `titlecase.browser.js` script in your HTML file:
+
+Here's an example of how to use the modulate function:
+
+```html
+<script src="./path/to/titlecase.browser.js"></script>
+```
+
+After that, the `toTitleCase()` function can be accessed in your JavaScript code like this:
+
+```js
+const options = { 
+  style: 'apa'
+};
+const input = 'the future of devops: the next era';
+const output = input.toTitleCase(options);
+
+console.log(output); // The Future of DevOps: The Next Era
+```
+
+## Options
+
+The `{options}` parameter is an object that contains the settings for the conversion process.
+
+- `style`: determines the specific title case style to be applied. Permissible values include: `['ap', 'apa', 'british', 'chicago', 'nyt', 'wikipedia']`
+- `articlesList` refers to the words that should be treated as articles in title case.
+- `shortConjunctionsList` pertains to the words that should be treated as short conjunctions in title case.
+- `shortPrepositionsList` relates to the words that should be treated as short prepositions in title case.
+- `neverCapitalizedList` contains the words that should never be capitalized in title case.
+- `wordReplacementsList` is a map of terms that will be replaced during the title case conversion process.
+
+## Methods
+
+- `setReplaceTerms(terms: object)`: Sets word replacement terms to be used during title casing. Multiple calls can be made to add or update multiple word replacements.
+- `removeReplaceTerm(term: string)`: Removes a replace term from the `wordReplacementsList` array in the options object of the `TitleCaser` instance. Throws an error if the term is not found in the array, otherwise removes it from the array and updates the options object.
+- `addReplaceTerm(term: string, replacement: string)`: Adds a new replace term to the wordReplacementsList array in the options object of the TitleCaser instance. The method takes two string arguments: term specifies the word to be replaced, and replacement specifies the replacement for the word. If the term already exists in the array, the method updates its replacement value. Otherwise, it adds a new object with the term and replacement to the array. The method then updates the wordReplacementsList property in the options object.
+- `setStyle(style: string)`: Sets the style option in the options object of the TitleCaser instance. The method takes a string argument style that specifies the style to use for the title casing. If the argument is not a string, the method throws a TypeError. Otherwise, it updates the style option in the options object.
+
+## Examples
+
+The example below demonstrates how to use the TitleCaser class to convert a string to title case with custom options.
+
+### Basic Usage
+
+```js
+// Instantiate a new TitleCaser object with the options
+const titleCaser = new TitleCaser();
+
+const input = 'the    Book  of  lIfe';
+const output = titleCaser.toTitleCase(input);
+
+console.log(output); // The Book of Life
+```
+
+### Customizing Word Replacements Method
+
+In the example below, we create a new instance of the `TitleCaser` class with the `APA` style option. We then set multiple replacement terms using two separate calls to the `setReplaceTerms()` method. Descriptive variable names are used for the input string and expected output. We call `toTitleCase()` to convert the input string to title case.
+
+```js
+// CommonJS
+const titleCaser = new TitleCaser({
+  style: 'apa'
+});
+
+// Set multiple replacement terms using two separate calls to setReplaceTerms()
+titleCaser.setReplaceTerms({ 
+  'hello world': 'Hello World', 
+  'replace me': 'Replace Me' 
+});
+titleCaser.setReplaceTerms({ 
+  'apa': 'APA' 
+});
+
+// Use descriptive variable names for the input and expected output
+const inputString = "hello world, replace me!";
+const expectedOutput = "Hello World, Replace Me!";
+
+// Call toTitleCase() to convert the input string to title case
+const outputString = titleCaser.toTitleCase(inputString);
+```
+
+### Customizing TitleCaser
+
+The example below demonstrates how to use the TitleCaser class to convert a string to title case with specific settings.
+
+```js
+// Set the options object
+const options = {
+  style: "nyt",
+  wordReplacementsList: {
+    "nodejs": "Node.js",
+    "javascript": "JavaScript",
+    "mongodb": "MongoDB"
+  }
+};
+
+// Instantiate a new TitleCaser object with the options
+const titleCaser = new TitleCaser(options);
+
+// Set the input string to test
+const input = "the basics of nodejs development with mongodb";
+
+// Set the expected output
+const expectedOutput = "The Basics of Node.js Development with MongoDB";
+
+// Call the toTitleCase method and store the result in actualOutput
+const actualOutput = titleCaser.toTitleCase(input);
+
+// Log the actual output
+console.log(actualOutput);
+```
+
+### TitleCaser With Default Word Replacement  
+
+The example below demonstrates how to use the TitleCaser class to convert a string to title case with AP style formatting, including hyphenated words and word/brand replacement.
+
+```js
+// Instantiate a new TitleCaser object with AP style formatting
+const titleCaser = new TitleCaser({ style: 'ap' });
+
+// Set the input string to test
+const input = 'nodejs development on aws: an in-depth tutorial on server-side javascript deployment';
+
+// Set the expected output
+const expectedOutput = 'Node.js Development on AWS: An In-depth Tutorial on Server-side JavaScript Deployment';
+
+// Call the toTitleCase method and store the result in actualOutput
+const actualOutput = titleCaser.toTitleCase(input);
+
+// Log the actual output
+console.log(actualOutput);
+```
+
+### TitleCaser With Possessive Noun and a Colon 
+
+The example below demonstrates how to use the TitleCaser class to convert a string to title case with AP style formatting, including a possessive noun and a colon.
+
+```js
+// Instantiate a new TitleCaser object with AP style formatting
+const titleCaser = new TitleCaser({ style: "ap" });
+
+// Set the input string to test
+const input = "the iphone's impact on modern communication: a sociolinguistic analysis";
+
+// Set the expected output
+const expectedOutput = "The iPhone's Impact on Modern Communication: A Sociolinguistic Analysis";
+
+// Call the toTitleCase method and store the result in actualOutput
+const actualOutput = titleCaser.toTitleCase(input);
+
+// Log the actual output
+console.log(actualOutput);
+```
+
+## Build Process
+
+```bash
+$ npm run build-package
+$ npm run build-docs
+$ npm run copy-package-to-docs
+$ npm run test
+```
+
+## Test
+
+```bash
+$ npm run test
+```
+
+```bash
+Test Basic Options
+✓ Default title case conversion
+✓ Customized title case conversion
+✓ AP-style title case conversion with replacements
+✓ AP-style title case conversion with replacements
+✓ Capitalize suffix word in sentence
+
+Test Methods
+✓ removeReplaceTerm
+✓ setReplaceTerms
+
+Test Variation Stability
+✓ Hyphenated, colon, and short word replacements
+✓ Capitalization and word replacements
+✓ AP-style title case with possessive and colon
+✓ AP-style title case with lowercase back/front-end terms
+✓ Chicago style title case with comparison and colon
+✓ APA style title case with colon
+✓ Wikipedia style title case with acronym and hyphen
+✓ APA style title case with colon and apostrophe
+✓ Chicago style title case with custom term replacements
+✓ AP-style capitalization test with special terms and colon
+✓ NYT-style capitalization test with special terms and colon
+✓ APA style capitalization test with short conjunction terms and colon
+✓ Correct phrase casing list testing
+✓ Wikipedia style capitalization test with special term and colon
+
+Test Reserved Words
+✓ Reserved word
+✓ Reserved word with colon
+✓ Reserved word, posessive
+✓ Hyphenated reserved word
+✓ Hyphenated reserved word, possessive
+✓ HTML line break nl2br, <br /> tag
+✓ Untrimmed white spaces
+```
+
+## Resources
+
+Useful materials for improving your knowledge of writing and language style guides. These resources include various books and manuals, such as the Publication Manual of the American Psychological Association, the Chicago Manual of Style, and the AP Stylebook, which are widely recognized as authoritative sources on grammar, punctuation, and capitalization rules.
+
+- [AP Stylebook, 56th Edition](https://store.stylebooks.com/ap-stylebook-56th-edition-print.html)
+- [Publication Manual of the American Psychological Association, Seventh Edition (2020)](https://apastyle.apa.org/products/publication-manual-7th-edition)
+- [Chicago Manual of Style: Capitalization](https://chat.openai.com/chat/643828ec-d4b5-4f21-b035-62946dd2cec3#:~:text=Chicago%20Manual%20of%20Style%3A%20Capitalization)
+- [The Bluebook: A Uniform System of Citation. 21st ed. Cambridge: Harvard Law Review Association, 2020](https://open.mitchellhamline.edu/cgi/viewcontent.cgi?article=2782&context=wmlr)
+- [The Chicago Manual of Style, 17th Edition](https://press.uchicago.edu/ucp/books/book/chicago/C/bo25956703.html)
+- [The New York Times Manual of Style and Usage](https://www.worldcat.org/title/946964415)
+- [Wikipedia: Letter case](https://chat.openai.com/chat/643828ec-d4b5-4f21-b035-62946dd2cec3#:~:text=Wikipedia%3A%20Letter%20case)
+- [Wikipedia:Manual of Style/Titles of works](https://en.wikipedia.org/wiki/Wikipedia:Manual_of_Style/Titles_of_works#Capital_letters)
+
+## Report Bugs
+
+If you encounter any bugs or issues while using the library or the demo page, please report them by opening a new issue in the repository's issue tracker. 
+
+When reporting a bug, please provide as much detail as possible, including the steps to reproduce the issue and any error messages that you see. I appreciate any contribution to improve this library.

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@danielhaim/titlecaser",
+  "version": "1.2.23",
+  "description": "Converts a string to title case with multiple style options, ability to ignore certain words, and handle acronyms",
+  "keywords": [
+    "titlecase",
+    "text transformation",
+    "capitalization",
+    "formatting"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/danielhaim1/titlecaser.git"
+  },
+  "main": "src/TitleCaser.js",
+  "scripts": {
+    "test": "jest",
+    "build-docs": "cd docs && bundle install && bundle exec jekyll build",
+    "build-package": "webpack --mode production && terser dist/titlecaser.js -o dist/titlecaser.min.js",
+    "copy-package-to-docs": "cp -R dist/ docs/assets/js",
+    "tree": "tree -I 'node_modules'",
+    "release": "npm version patch && npm run build-package && npm run copy-package-to-docs && git add package.json package-lock.json dist/ docs/assets/js && git commit -m 'Bump version and build package for release' && git push"
+  },
+  "files": [
+    "LICENSE",
+    "README.md",
+    "package.json",
+    "src/index.js",
+    "src/TitleCaseConsts.js",
+    "src/TitleCaser.js",
+    "src/index.js"
+  ],
+  "author": {
+    "name": "Daniel Haim",
+    "url": "https://github.com/danielhaim1"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "@babel/cli": "^7.21.0",
+    "@babel/core": "^7.21.0",
+    "@babel/plugin-transform-modules-commonjs": "^7.21.2",
+    "@babel/preset-env": "^7.20.2",
+    "@babel/runtime-corejs3": "^7.21.0",
+    "babel-loader": "^9.1.2",
+    "esbuild-jest": "^0.5.0",
+    "exports-loader": "^4.0.0",
+    "terser-webpack-plugin": "^5.3.7",
+    "webpack": "^5.76.3",
+    "webpack-cli": "^5.0.1",
+    "webpack-node-externals": "^3.0.0",
+    "@jest/expect": "^29.5.0",
+    "babel-jest": "^29.5.0",
+    "jest": "^29.5.0",
+    "jest-environment-jsdom": "^29.5.0",
+    "jest-environment-puppeteer": "^8.0.5",
+    "jest-puppeteer": "^8.0.5",
+    "puppeteer": "^19.8.2",
+    "puppeteer-core": "^19.8.0"
+  }
+}

package/src/TitleCaseConsts.js

@@ -0,0 +1,214 @@
+export const commonAbbreviationList = [
+  'a', 'an', 'the', 'as', 'at', 'by', 'for', 'in', 'of', 'on',
+  'to', 'up', 'yet', 'so', 'but', 'nor', 'or', 'and',
+];
+
+export const correctTitleCasingList = [
+  // Web Technologies
+  'AJAX', 'CSS', 'DOM', 'ES6', 'HTML', 'JavaScript', 'jQuery',
+  'MobX', 'SCSS', 'TypeScript', 'Vue.js', '.NET', 'ASP', 'ASPX',
+  'MySQL', 'PHP', 'PostgreSQL', 'Python', 'SQL', 'GraphQL',
+  'HTML5',
+
+  // Acronyms/Abbreviations
+  'API', 'APIs', 'ASCII', 'CI', 'CircleCI', 'CLI', 'DLL', 'DNS',
+  'EC2', 'FTP', 'HTTP', 'HTTPs', 'ICMP', 'IDE', 'IP', 'ISP',
+  'JSON', 'JSP', 'LPWAN', 'M2M', 'MQTT', 'OOP', 'REST', 'SSH',
+  'SSL', 'TCP', 'UDP', 'URL', 'WLAN', 'WYSIWYG', 'XML', 'YAML',
+  'YML', 'IMAP', 'RSS', 'IaaS', 'PaaS', 'SaaS', 'CaaS', 'FaaS',
+  'XaaS', 'RaaS', 'IoE', 'IoT', 'LoRa', 'NB-IoT', 'RFID', 'RF',
+  'RFI', 'RFQ', 'ECMAScript', 'IO', 'I/O', 'DevOps', 'SecOps',
+  'DDoS', 'VoIP', 'AI', 'AR', 'ML', 'VR',
+
+  // Misc.
+  'w/', 'w/o',
+
+  // 'eTerms'
+  'e-Book', 'e-Books', 'eBook', 'eBooks', 'eCommerce',
+  'eMarket', 'eMarketplace', 'eMarketplaces', 'eMarkets',
+  'eReader', 'eShop', 'eShops', 'eStore', 'eStores',
+  'E-commerce',
+
+  // Accounting terms
+  'AP', 'COGS', 'EBIT', 'EPS', 'FIFO', 'GAAP', 'LIFO',
+  'P&L', 'ROI', 'SOX', 'TCO', 'VAT',
+
+  // Investment terms
+  'CAGR', 'DCF', 'ETF', 'IPO', 'IRR', 'M&A', 'NAV', 'PE', 'PEG',
+  'PPE', 'ROE', 'S&P', 'TVM', 'VC',
+
+  // Marketing terms
+  'B2B', 'B2C', 'CMO', 'CPA', 'CPC', 'CPL', 'CPM', 'CRM', 'CTA',
+  'CTR', 'SEO', 'SEM', 'SMM', 'USP', 'A/B', 'CTA', 'CTOR',
+  'CTR', 'KPI', 'PWA', 'SEM', 'SERP', 'SERPs', 'SMM', 'SMO',
+  'FAQ', 'FAQA', 'FAQS', 'UI', 'UI/UX', 'UX', 'T&C', 'TOS',
+  'PP', 'CRM', 'PoE', 'PoW', 'PoC', 'A11Y', 'PR',
+
+  // Sales terms
+  'BANT', 'GAP', 'KPI', 'MQL', 'NPS', 'POS', 'SPIN', 'SQL',
+  'SWOT',
+
+  // Legal terms
+  'AFA', 'ADR', 'CCPA', 'CFAA', 'CISG', 'DMCA', 'EULA', 'GDPR',
+  'HIPAA', 'NDA', 'SOW', 'TOS',
+
+  // Roles and titles
+  'CEO', 'CEOs', 'CFO', 'CFOs', 'CIO', 'CIOs', 'CMO', 'CMOs',
+  'COO', 'COOs', 'CPO', 'CPOs', 'CRO', 'CROs', 'CSO', 'CSOs',
+  'CTO', 'CTOs', 'EVP', 'EVPs', 'HR', 'HRs', 'SVP', 'SVPs',
+  'VP', 'VPs',
+
+  // Non-profit organizations
+  'NGO', 'NPO', 'NGOs', 'NPOs', 'UN', 'UNESCO', 'UNICEF',
+  'UNHCR', 'UNODC', 'UNDP', 'UNFPA', 'UNEP',
+
+  'Adobe', 'Airbnb', 'Alibaba', 'Allstate', 'American Express', 'Apple',
+  'AT&T', 'BMW', 'Boeing', 'Cisco', 'Citigroup', 'Coca', 'Deloitte', 'Disney',
+  'Dropbox', 'ExxonMobil', 'Ford', 'GE', 'General', 'Goldman Sachs', 'Google',
+  'Hilton', 'HP', 'IBM', 'Intel', 'JPMorgan', 'Johnson & Johnson', 'LinkedIn',
+  "McDonald's", 'Mercedes-Benz', 'Microsoft', 'Nestle', 'Nike', 'Nissan',
+  'Oracle', 'PepsiCo', 'Pfizer', 'Salesforce', 'Samsung', 'Shell', 'Sony',
+  'Tesla', 'Toyota', 'Uber', 'Verizon', 'Visa', 'Walmart', 'Wells Fargo',
+  'Yahoo', 'Zara', 'IKEA', 'Facebook', 'YouTube', 'Instagram', 'Twitter',
+  'TensorFlow', 'Amazon', 'Netflix', 'eBay', 'iPhone', 'iPad', 'iPod',
+  'PlayStation', 'PayPal', 'GitHub', 'GitLab', 'CodeIgniter', 'WordPress',
+  'WooCommerce', 'MongoDB', 'JIRA', 'HubSpot', 'AirDrop', 'AirPlay', 'AirPods',
+  'AirTags', 'FinalCut', 'GarageBand', 'iBooks', 'iCloud', 'iLife', 'iMac',
+  'iMessage', 'iMovie', 'iPhoto', 'iWatch', 'iWork', 'LogicPro', 'macOS',
+  'ProTools', 'QuickTime', 'AdWords', 'AdSense', 'TikTok', 'Slack', 'Trello',
+  'Zoom', 'Twitch', 'Snapchat', 'WhatsApp', 'Telegram', 'Discord', 'Reddit',
+  'Quora', 'StackOverflow', 'StackExchange', 'Coca-Cola',
+  'AWS', 'GCP', 'VMware', 'CVS',
+
+  // Sports
+  'NBA', 'NCAA', 'NFL', 'WWE', 'WWF', 'FIFA',
+
+  // Time-related, numbers, and measurements: Includes abbreviations for
+  // time-related terms, numbers, and measurements.
+  'a.m.', 'p.m.', 'ca.', 'cc.', 'fig.', 'pl.', 'pt.', 'rev.',
+  'sr.', 'v.', 'vol.', 'et al.', 'pp.', 'p.',
+
+  // Professional abbreviations, degrees, and titles: Includes abbreviations
+  // for professional titles, degrees, and certifications.
+  'ph.d.', 'm.d.', 'd.d.s.', 'd.m.d.', 'd.o.', 'd.c.', 'd.v.m.',
+  'd.n.p.', 'd.p.m.', 'd.s.w.', 'd.s.n.', 'd.n.sc.', 'd.n.a.',
+  'd.n.t.', 'd.n.p.t.', 'd.n.o.', 'd.n.m.', 'd.n.e.', 'd.n.s.',
+  'd.n.p.s.',
+
+  // Academic & literary abbreviations: Includes abbreviations for academic 
+  // and literary terms, such as 'ed.' for 'edition' and 'vol.' for 'volume'.
+  'adj.', 'adv.', 'cf.', 'cm.', 'co.', 'corp.', 'dept.',
+  'dist.', 'ed.', 'edn.', 'esp.', 'etc.', 'ex.', 'i.e.', 'e.g.',
+  'op. cit.', 'vs.',
+
+  // Commercial
+  'Ltd.', 'Co.', 'Inc.', 'St.', 'Ave.', 'Bldg.', 'No.',
+];
+
+export const wordReplacementsList = [
+  { 'a.k.a': 'AKA' },
+  { 'a.s.a.p': 'ASAP' },
+  { 'angularjs': 'Angular.js' },
+  { 'back-end': 'Backend' },
+  { 'd.i.y': 'DIY' },
+  { 'e-book': 'eBook' },
+  { 'e-books': 'eBooks' },
+  { 'e-commerce': 'eCommerce' },
+  { 'ecom': 'eCommerce' },
+  { 'ecommerce': 'eCommerce' },
+  { 'f.a.q': 'FAQ' },
+  { 'f.a.q.a': 'FAQs' },
+  { 'f.a.q.s': 'FAQs' },
+  { 'f.y.i': 'FYI' },
+  { 'front-end': 'Frontend' },
+  { 'full-stack': 'Fullstack' },
+  { 'nextjs': 'Next.js' },
+  { 'nodejs': 'Node.js' },
+  { 'nuxtjs': 'Nuxt.js' },
+  { 'reactjs': 'React.js' },
+  { 't.b.d': 'TBD' },
+  { 'vuejs': 'Vue.js' },
+  { 'phd': 'ph.d.' },
+];
+
+// ! TODO
+// const wordReplacementsList = [
+//     { word: 'a.k.a', replacement: 'AKA' },
+//     { word: 'a.s.a.p', replacement: 'ASAP' },
+//     { word: 'angularjs', replacement: 'Angular.js' },
+//     { word: 'back-end', replacement: 'Backend' },
+//     { word: 'd.i.y', replacement: 'DIY' },
+//     { word: 'e-book', replacement: 'eBook' },
+//     { word: 'e-books', replacement: 'eBooks' },
+//     { word: 'e-commerce', replacement: 'eCommerce' },
+//     { word: 'ecom', replacement: 'eCommerce' },
+//     { word: 'ecommerce', replacement: 'eCommerce' },
+//     { word: 'f.a.q', replacement: 'FAQ' },
+//     { word: 'f.a.q.a', replacement: 'FAQs' },
+//     { word: 'f.a.q.s', replacement: 'FAQs' },
+//     { word: 'f.y.i', replacement: 'FYI' },
+//     { word: 'front-end', replacement: 'Frontend' },
+//     { word: 'full-stack', replacement: 'Fullstack' },
+//     { word: 'nextjs', replacement: 'Next.js' },
+//     { word: 'nodejs', replacement: 'Node.js' },
+//     { word: 'nuxtjs', replacement: 'Nuxt.js' },
+//     { word: 'reactjs', replacement: 'React.js' },
+//     { word: 't.b.d', replacement: 'TBD' },
+//     { word: 'vuejs', replacement: 'Vue.js' },
+//     { word: 'phd', replacement: 'ph.d.' },
+// ];
+
+export const titleCaseStylesList = Object.freeze({
+  AP: 'ap',
+  APA: 'apa',
+  BRITISH: 'british',
+  CHICAGO: 'chicago',
+  NYT: 'nyt',
+  WIKIPEDIA: 'wikipedia'
+});
+export const allowedTitleCaseStylesList = Object.values(titleCaseStylesList);
+export const titleCaseDefaultOptionsList = Object.freeze({
+  ap: {
+    shortConjunctionsList: ['and', 'but', 'or', 'for', 'nor', 'yet', 'so'],
+    articlesList: ['a', 'an', 'the'],
+    shortPrepositionsList: ['as', 'at', 'by', 'in', 'of', 'on', 'to', 'up', 'via'],
+    neverCapitalizedList: []
+  },
+  apa: {
+    shortConjunctionsList: ['and', 'as', 'but', 'by', 'for', 'in', 'nor', 'of', 'on', 'or', 'so', 'to', 'yet'],
+    articlesList: ['a', 'an', 'the'],
+    shortPrepositionsList: ['as', 'at', 'by', 'for', 'in', 'of', 'on', 'to', 'up', 'via'],
+    neverCapitalizedList: []
+  },
+  british: {
+    shortConjunctionsList: ['and', 'but', 'or', 'for', 'nor', 'yet', 'so'],
+    articlesList: ['a', 'an', 'the'],
+    shortPrepositionsList: ['as', 'at', 'by', 'in', 'of', 'on', 'to', 'up', 'via'],
+    neverCapitalizedList: []
+  },
+  chicago: {
+    shortConjunctionsList: ['and', 'but', 'or', 'for', 'nor', 'yet', 'so'],
+    articlesList: ['a', 'an', 'the'],
+    shortPrepositionsList: ['as', 'at', 'by', 'for', 'in', 'of', 'on', 'to', 'up', 'with', 'via'],
+    neverCapitalizedList: ['etc.']
+  },
+  nyt: {
+    shortConjunctionsList: ['and', 'but', 'or', 'for', 'nor', 'yet', 'so'],
+    articlesList: ['a', 'an', 'the'],
+    shortPrepositionsList: ['as', 'at', 'by', 'in', 'of', 'on', 'to', 'up', 'via'],
+    neverCapitalizedList: []
+  },
+  wikipedia: {
+    shortConjunctionsList: ['and', 'as', 'but', 'for', 'if', 'nor', 'or', 'so', 'yet'],
+    articlesList: ['a', 'an', 'the'],
+    shortPrepositionsList: ['as', 'at', 'by', 'in', 'of', 'on', 'to', 'up', 'via'],
+    neverCapitalizedList: []
+  },
+});
+
+export const ignoredWordsList = [];
+export const correctPhraseCasingList = [
+  'The Cybersmile Foundation',
+  'CO. by Colgate',
+  "The Simpsons",
+];

package/src/TitleCaser.js

@@ -0,0 +1,220 @@
+import {
+    commonAbbreviationList,
+    correctTitleCasingList,
+    correctPhraseCasingList,
+    wordReplacementsList,
+}
+    from "./TitleCaseConsts.js";
+
+import TitleCaseHelper from "./TitleCaseHelper.js";
+
+export class TitleCaser {
+    constructor (options = {}) {
+        this.options = options;
+        this.wordReplacementsList = wordReplacementsList;
+    }
+    toTitleCase(str) {
+        try {
+            // If input is empty, throw an error.
+            if (str.trim().length === 0) throw new TypeError("Invalid input: input must not be empty.");
+
+            // If input is not a string, throw an error.
+            if (typeof str !== 'string') throw new TypeError("Invalid input: input must be a string.");
+
+            // If options is not an object, throw an error.
+            if (typeof this.options !== "undefined" && typeof this.options !== "object") throw new TypeError("Invalid options: options must be an object.");
+
+            const { 
+                style = "ap",
+                neverCapitalize = [],
+                replaceTermsList = wordReplacementsList
+            } = this.options;
+            const ignoreList = ["nl2br", ...neverCapitalize];
+            const {
+                articlesList,
+                shortConjunctionsList,
+                shortPrepositionsList,
+                neverCapitalizedList,
+                replaceTerms
+          } = TitleCaseHelper.getTitleCaseOptions(this.options, commonAbbreviationList, wordReplacementsList);
+
+          // Prerocess the replaceTerms array to make it easier to search for.
+          const replaceTermsArray = replaceTermsList.map(term => Object.keys(term)[0].toLowerCase());
+          // Create an object from the replaceTerms array to make it easier to search for.
+          const replaceTermsObj = Object.fromEntries(replaceTermsList.map(
+            term => [Object.keys(term)[0].toLowerCase(), Object.values(term)[0]]
+          ));
+
+
+            // Remove extra spaces and replace <br> tags with a placeholder.
+            let inputString = str.trim();
+
+            // Remove extra spaces and replace <br> tags with a placeholder.
+            inputString = inputString.replace(/ {2,}/g, (match) => match.slice(0, 1));
+
+            // Replace <br> tags with a placeholder.
+            inputString = inputString.replace(/<br\s*[\/]?>/gi, "nl2br ");
+
+            // Split the string into an array of words.
+            const words = inputString.split(" ");
+            
+            const wordsInTitleCase = words.map((word, i) => {
+                switch (true) {
+                    case TitleCaseHelper.hasHtmlBreak(word):
+                        // If the word is a <br> tag, return it as is.
+                        return word;
+                    case TitleCaseHelper.isWordIgnored(word, ignoreList):
+                        // If the word is in the ignore list, return it as is.
+                        return word;
+                    case replaceTermsArray.includes(word.toLowerCase()):
+                        // If the word is in the replaceTerms array, return the replacement.
+                        return replaceTermsObj[word.toLowerCase()];
+                    case TitleCaseHelper.isWordInArray(word, correctTitleCasingList):
+                        // If the word is in the correctTitleCasingList array, return the correct casing.
+                        return TitleCaseHelper.correctTerm(word, correctTitleCasingList);
+                    case TitleCaseHelper.hasSuffix(word, style):
+                        // If the word has a suffix, return the correct casing.
+                        return TitleCaseHelper.correctSuffix(word, correctTitleCasingList);
+                    case TitleCaseHelper.hasHyphen(word):
+                        // If the word has a hyphen, return the correct casing.
+                        return TitleCaseHelper.correctTermHyphenated(word, style);
+                    case TitleCaseHelper.hasUppercaseIntentional(word):
+                        // If the word has an intentional uppercase letter, return the correct casing.
+                        return word;
+                    case TitleCaseHelper.isShortWord(word, style) && i !== 0:
+                        // If the word is a short word, return the correct casing.
+                        return (i > 0 && TitleCaseHelper.endsWithSymbol(words[i - 1],
+                            [':', '?', '!', '.'])) ? word.charAt(0).toUpperCase() + word.slice(1) : word.toLowerCase();
+                    case TitleCaseHelper.endsWithSymbol(word):
+                        // If the word ends with a symbol, return the correct casing.
+                        const splitWord = word.split(/([.,\/#!$%\^&\*;:{}=\-_`~()])/g);
+                        const processedWords = splitWord.map((splitWord, j) => {
+                            // If the word is in the correctTitleCasingList array, return the correct casing.
+                            if (TitleCaseHelper.isWordInArray(splitWord, correctTitleCasingList)) return TitleCaseHelper.correctTerm(splitWord, correctTitleCasingList);
+                            // Else return the word with the correct casing.
+                            else return (j > 0 && TitleCaseHelper.endsWithSymbol(splitWord)) ? splitWord.charAt(0)
+                                .toUpperCase() + splitWord.slice(1) : splitWord.charAt(0)
+                                    .toUpperCase() + splitWord.slice(1);
+                        });
+                        // Join the processed words and return them.
+                        return processedWords.join("");
+                    case TitleCaseHelper.startsWithSymbol(word):
+                        // If the word starts with a symbol, return the correct casing.
+                        return !TitleCaseHelper.isWordInArray(word, correctTitleCasingList) ? word : TitleCaseHelper.correctTerm(word);
+                    case TitleCaseHelper.hasRomanNumeral(word):
+                        // If the word has a roman numeral, return the correct casing.
+                        return word.toUpperCase();
+                    case TitleCaseHelper.hasNumbers(word):
+                        // If the word has numbers, return the correct casing.
+                        return word;
+                    default:
+                        // Default to returning the word with the correct casing.
+                        return word.charAt(0)
+                            .toUpperCase() + word.slice(1)
+                                .toLowerCase();
+                }
+            });
+
+            // Join the words in the array into a string.
+            inputString = wordsInTitleCase.join(" ");
+            
+            for (const phrase of correctPhraseCasingList) {
+                // If the phrase is in the input string, replace it with the correct casing.
+                if (inputString.toLowerCase()
+                    .includes(phrase.toLowerCase())) {
+                    inputString = inputString.replace(new RegExp(phrase, 'gi'), phrase);
+                }
+            }
+
+            // Replace the nl2br placeholder with <br> tags.
+            inputString = inputString.replace(/nl2br /gi, "<br />");
+
+            // Return the string.
+            return inputString;
+        }
+        catch (error) {
+            throw new Error(error);
+        }
+    }
+
+    setReplaceTerms(terms) {
+      if (typeof terms !== 'object') {
+        throw new TypeError('Invalid argument: replace terms must be an object.');
+      }
+
+      // Add the new replace terms to the wordReplacementsList array
+      Object.entries(terms).forEach(([term, replacement]) => {
+        const index = wordReplacementsList.findIndex(obj => obj[term]);
+        if (index !== -1) {
+          // If the term already exists in the array, update the replacement value
+          wordReplacementsList[index][term] = replacement;
+        } else {
+          // If the term doesn't exist in the array, add a new object with the term and replacement
+          wordReplacementsList.push({ [term]: replacement });
+        }
+      });
+
+      // Log the updated wordReplacementsList array
+      // console.log(wordReplacementsList);
+
+      // Update the replace terms option
+      this.options.wordReplacementsList = wordReplacementsList;
+    }
+
+    addReplaceTerm(term, replacement) {
+        if (typeof term !== 'string' || typeof replacement !== 'string') {
+          throw new TypeError('Invalid argument: term and replacement must be strings.');
+        }
+
+        const index = this.wordReplacementsList.findIndex(obj => obj[term]);
+        
+        if (index !== -1) {
+          // If the term already exists in the array, update the replacement value
+          this.wordReplacementsList[index][term] = replacement;
+        } else {
+          // If the term doesn't exist in the array, add a new object with the term and replacement
+          this.wordReplacementsList.push({ [term]: replacement });
+        }
+
+        // Update the replace terms option
+        this.options.wordReplacementsList = this.wordReplacementsList;
+    }
+
+    removeReplaceTerm(term) {
+        if (typeof term !== 'string') {
+            throw new TypeError('Invalid argument: term must be a string.');
+        }
+
+        // Find the index of the term in the wordReplacementsList array
+        const index = this.wordReplacementsList.findIndex(obj => Object.keys(obj)[0] === term);
+
+        // If the term is not found in the array, throw an error
+        if (index === -1) {
+            throw new Error(`Term '${term}' not found in word replacements list.`);
+        }
+
+        // Remove the term from the array
+        this.wordReplacementsList.splice(index, 1);
+
+        // Log the updated wordReplacementsList array
+        // console.log(this.wordReplacementsList);
+
+        // Update the replace terms option
+        this.options.wordReplacementsList = this.wordReplacementsList;
+    }
+
+    setStyle(style) {
+        if (typeof style !== 'string') {
+            throw new TypeError('Invalid argument: style must be a string.');
+        }
+        
+        this.options.style = style;
+    }
+}
+
+// If the module is being used in a Node environment, export the module.
+if (typeof module === 'object' && module.exports) {
+    module.exports = { TitleCaser };
+}
+
+

package/src/index.js

@@ -0,0 +1,14 @@
+import { TitleCaser } from './TitleCaser.js';
+
+if (typeof String.prototype.toTitleCase !== 'function') {
+  String.prototype.toTitleCase = function (options) {
+    const titleCaser = new TitleCaser(options);
+    return titleCaser.toTitleCase(this);
+  };
+}
+
+export { TitleCaser };
+
+if (typeof window === 'object') {
+  window.TitleCaser = TitleCaser;
+}