stringweaver 1.4.0 → 1.4.3

package/src/Factories/{interpolateFactory.js → splatESBundle.js}

@@ -1,14 +1,28 @@
-const defaultInterpolator = interpolateFactory();
-export {defaultInterpolator as default, interpolateFactory};
+const IS = typeCheckFactory();
+const interpolateDefault = interpolateFactory();
+const interpolateClear = interpolateFactory("");
+
+export {
+  interpolateDefault as default,
+  interpolateClear,
+  addSymbolicStringExtensions,
+  interpolateFactory,
+};
 
 /**
  * Factory function to create an interpolate function with a default replacer.
- * @param {string} defaultReplacer - Default value to use for missing tokens.
+ * @param {string|number} defaultReplacer - Default value to use for missing tokens.
  * @returns {Function} - The interpolation function.
  */
-function interpolateFactory(defaultReplacer = "") {
-  defaultReplacer = defaultReplacer?.constructor === String ? defaultReplacer : "";
-
+function interpolateFactory(defaultReplacer, specs = {}) {
+  const {useSymbolicExtensions} = specs;
+  defaultReplacer = IS(defaultReplacer, String, Number) ?
+    String(defaultReplacer) : undefined;
+  
+  if (!!useSymbolicExtensions) {
+    addSymbolicStringExtensions();
+  }
+  
   /**
    * Main interpolation function.
    * @param {string} str - The string with placeholders.
@@ -18,7 +32,7 @@ function interpolateFactory(defaultReplacer = "") {
   return function(str, ...tokens) {
     return interpolate(str, processTokens(tokens));
   }
-
+  
   /**
    * Handle invalid keys by returning the default replacer or the key in braces.
    * @param {string} key - The placeholder key.
@@ -26,22 +40,13 @@ function interpolateFactory(defaultReplacer = "") {
    * @returns {string} - The replacement value.
    */
   function invalidate(key, keyExists) {
-    if (keyExists && defaultReplacer.length > 0) {
+    if (keyExists && IS(defaultReplacer, String, Number)) {
       return String(defaultReplacer);
     }
-
+    
     return `{${key}}`;
   }
-
-  /**
-   * determine if [value] is a String or Number
-   * @param {any} value
-   * @returns {boolean}
-   */
-  function isStringOrNumber(value ) {
-    return value?.constructor === String || value?.constructor === Number && !Number.isNaN(value);
-  }
-
+  
   /**
    * Get the replacement value for a key from the token.
    * @param {string} key - The placeholder key.
@@ -50,9 +55,9 @@ function interpolateFactory(defaultReplacer = "") {
    */
   function replacement(key, token) {
     const isValid = key in token;
-    return isValid && isStringOrNumber(token[key]) ? String(token[key]) : invalidate(key, isValid);
+    return isValid && IS(token[key], String, Number) ? String(token[key]) : invalidate(key, isValid);
   }
-
+  
   /**
    * Create a lambda function for replacing placeholders in the string.
    * @param {object} token - The token object containing replacement values.
@@ -64,7 +69,7 @@ function interpolateFactory(defaultReplacer = "") {
       return replacement((replacementObject ? replacementObject.key : `_`), token);
     };
   }
-
+  
   /**
    * Replace placeholders in the string with values from the token.
    * @param {string} str - The string with placeholders.
@@ -74,24 +79,23 @@ function interpolateFactory(defaultReplacer = "") {
   function replace(str, token) {
     return str.replace(/\{(?<key>[a-z_\d]+)}/gim, getReplacerLambda(token));
   }
-
+  
   /**
    * Convert token object to array of token Objects
    * when it's values are arrays of values.
    * @param {object} tokenObject - The token object containing arrays of values.
    * @returns {object[]} - Array of token objects.
    */
-  /* node:coverage disable (internal method, not covered by tests)*/
   function convertTokensFromArrayValues(tokenObject) {
     const converted = [];
-
+    
     Object.entries(tokenObject).forEach(([key, value]) => {
       value.forEach((v, i) => (converted[i] ??= {}, converted[i][key] = v));
     });
-
+    
     return converted;
   }
-
+  
   /**
    * Check if single token and its values are arrays.
    * @param {object[]} tokens - The tokens to check.
@@ -101,7 +105,7 @@ function interpolateFactory(defaultReplacer = "") {
   function isMultiLineWithArrays(tokens) {
     return tokens.length === 1 && Object.values(tokens[0]).every(Array.isArray);
   }
-
+  
   /**
    * Process tokens to handle multi-line formats.
    * @param {object[]} tokens - The tokens to process.
@@ -110,16 +114,7 @@ function interpolateFactory(defaultReplacer = "") {
   function processTokens(tokens) {
     return isMultiLineWithArrays(tokens) ? convertTokensFromArrayValues(tokens[0]) : tokens;
   }
-
-  /**
-   * Determine [value] is a real Object and contains keys and values
-   * @param {any} value
-   * @returns {boolean}
-   */
-  function isKeyValueObject(value) {
-    return !Array.isArray(value) && value?.constructor === Object && Object.entries(value)?.length > 0;
-  }
-
+  
   /**
    * Interpolate the string with the given tokens.
    * @param {string} str - The string with placeholders.
@@ -127,9 +122,86 @@ function interpolateFactory(defaultReplacer = "") {
    * @returns {string} - The interpolated string.
    */
   function interpolate(str, tokens) {
-    return !tokens?.length ? str : tokens
-      .filter(token => token)
-      .map((token, i) => isKeyValueObject(token) ? replace(str, {...token, index: i+1}) : ``)
+    const injected = !tokens?.length ? str : tokens
+      .filter(token => IS(token, Object))
+      .map((token, i) => replace(str, {...token, index: i + 1}))
       .join(``);
+    
+    return IS(defaultReplacer, undefined)
+      ? injected : injected.replace(/\{[a-z_\d].+\}/gim, String(defaultReplacer));
+  }
+}
+
+/**
+ * Extend String.prototype using the above two
+ * interpolate methods.
+ * Note: Symbols are unique, so there is no risk the
+ * methods will conflict with native String methods or
+ * methods in other ES libraries.
+ * @returns {symbol[]}
+ */
+function addSymbolicStringExtensions() {
+  if (!String.prototype[Symbol.for(`interpolate`)]) {
+    Object.defineProperties(String.prototype, {
+      [Symbol.for(`interpolate`)]: {
+        value(...args) {
+          return interpolateDefault(this, ...args);
+        }
+      },
+      [Symbol.for(`interpolate$`)]: {
+        value(...args) {
+          return interpolateClear(this, ...args);
+        }
+      },
+    });
+  }
+  
+  return [Symbol.for("interpolate"), Symbol.for(`interpolate$`)];
+}
+
+/**
+ * Simple 'type' checking factory
+ * @returns {function(*, ...[*]): (boolean|*)}
+ */
+function typeCheckFactory() {
+  const collate = new Intl.Collator(`en`, {sensitivity: 'base'});
+  const nameOf = type2Check => typeof type2Check === `function`
+    ? type2Check?.name || type2Check?.constructor?.name : `noCTOR`;
+  
+  /**
+   * check obj to be of [type2Check]
+   * @param {*} obj
+   * @param {*} type2Check
+   * @returns {boolean}
+   */
+  function checkSingleType(obj, type2Check) {
+    if (type2Check === Number && (Number.isNaN(obj) || !Number.isFinite(obj))) {
+      return false;
+    }
+    
+    return 0 === collate.compare(
+      Object.prototype.toString.call(obj),
+      `[object ${nameOf(type2Check)}]`
+    ) || obj?.name === type2Check?.name;
+  }
+  
+  /**
+   *
+   * @param {*} obj
+   * @param {*[]} type2Check
+   * @returns {boolean}
+   */
+  function checkType(obj, ...type2Check) {
+    if (type2Check.length > 1) {
+      for (const chkType of type2Check) {
+        if (checkSingleType(obj, chkType)) { return true; }
+      }
+      
+      return false;
+    }
+    
+    return checkSingleType(obj, type2Check?.shift());
   }
+  
+  return checkType;
 }

package/src/{genericMethods.js → helpers.js}

@@ -1,110 +1,92 @@
-import {default as randomString, uuid4}  from "./Factories/randomStringFactory.js";
-import interpolate from "./Factories/interpolateFactory.js";
+import interpolate from "./factories/splatESBundle.js";
 import createRegExp from "./Factories/regExpFromMultilineStringFactory.js";
-import createInstance from "./extensions.js";
-const customMethods = {};
+import {default as randomString, uuid4}  from "./Factories/randomStringFactory.js";
+import {CustomStringConstructor} from "./CTORCreator.js";
+import {parseCamelcase, parseKebabCase, parseSnakeCase, ucFirst, wordsFirstUp} from "./instanceMethods.js";
 const quotingStyles = defineQuotingStyles();
+const deprecatedRE = /symbol|anchor|big|blink|bold|fixed|fontsize|fontcolor|italics|link|small|strike|sup|sub/i
 
 export {
-  customMethods,
-  CustomStringConstructor,
-  isNumber,
-  isArrayOf,
-  quotGetters4Instance,
-  getStringValue,
-  escapeRE,
-  resolveTemplateString,
-  clone,
-  interpolate,
-  quotingStyles,
-  createRegExp,
+  capitalizerFactory, createExtendedCTOR, createRegExp, defineQuotingStyles,
+  deprecatedRE, getStringValue, escapeRE, infoValue, interpolate, isArrayOf, isNumber,
+  randomString, resolveTemplateString, retrieveQuotInfo, quotGetters4Instance, uuid4,
 };
 
-createExtendedCTOR(CustomStringConstructor, customMethods);
-
-function CustomStringConstructor(str, ...args) {
-  const instance = createInstance({initialstring: resolveTemplateString(str, ...args)});
-  Object.defineProperty( instance,
-    `constructor`, { get() { return CustomStringConstructor; }, enumerable: false}
-  );
-  return Object.freeze(instance);
-}
-
-function resolveTemplateString(str, ...args) {
-  return str?.raw
-    ? String.raw({ raw: str }, ...args)
-    : getStringValue(str).length ? str : "";
+function defineQuotingStyles() {
+  // see https://en.wikipedia.org/wiki/Quotation_mark
+  const quots = {
+    backtick: ["`", "`"],
+    parentheses: [`(`, `)`],
+    curlyBrackets: [`{`, `}`],
+    curlyDoubleInward: [`”`, `“`],
+    curlyDouble: [`“`, `”`],
+    curlyDoubleEqual: [`“`, `“`],
+    curlyLHDouble: [`„`, `”`],
+    curlyLHDoubleInward: [`„`, `“`],
+    curlyLHSingle: [`‚`, `’`],
+    curlyLHSingleInward: [`‚`, `‘`],
+    curlySingle: [`‛`, `’`],
+    curlySingleEqual: [`‛`, `‛`],
+    curlySingleInward: [`’`, `‛`],
+    double: [`"`, `"`],
+    guillemets: [`«`, `»`],
+    guillemetsInward: [`»`, `«`],
+    guillemetsSingle: [`‹`, `›`],
+    guillemetsSingleInward: [`›`, `‹`],
+    single: [`'`, `'`],
+    squareBrackets: [`[`, `]`],
+  };
+  quots.re = escapeRE([...new Set(
+    Object.values(quots)
+      .filter(v => Array.isArray(v))
+      .flat())].join(``), "g");
+  return quots;
 }
 
-function isArrayOf(type, value, includeInstances = true) {
-  return Array.isArray(value) && value.length > 0 && !value.find(v => checkType(type, v, includeInstances));
+function escapeRE(reString, modifiers) {
+  return new RegExp(reString.replace(/\p{S}|\p{P}/gu, a => `\\${a}`), modifiers);
 }
 
-function clone(instance) {
-  const newInstance = CustomStringConstructor(instance.value);
-  newInstance.history = [...instance.history];
-  return newInstance;
-}
 
 function getStringValue(string) {
   return string?.value || (string?.constructor === String && string) || ``;
 }
 
-function isNumber(value) {
-  return value?.constructor === Number && !Number.isNaN(value);
-}
-
-function escapeRE(reString, modifiers) {
-  return new RegExp(reString.replace(/\p{S}|\p{P}/gu, a => `\\${a}`), modifiers);
+function isArrayOf(type, value, includeInstances = true) {
+  return Array.isArray(value) && value.length > 0 &&
+    !value.find(v => checkType(type, v, includeInstances));
 }
 
-function escape4RE(reString) {
-  return reString.replace(/\p{S}|\p{P}/gu, a => `\\${a}`);
+function isNumber(value) {
+  return value?.constructor === Number && !Number.isNaN(value);
 }
 
 function infoValue(key, infoValue) {
   return `${key} (${infoValue})`;
 }
 
-function getPlainValues() {
-  const capitalizerKeys = Object.keys(CustomStringConstructor.create.capitalize);
-  return {
-    value: `getter/setter`,
-    clone: `chainable getter`,
-    notEmpty: `chainable getter|undefined`,
-    quote: `Object. See [constructor].quoteInfo`,
-    capitalize: `getter. Object with chainable getters: [${capitalizerKeys.join(`, `)}]`,
-  };
+function checkType(type, item, includeInstances) {
+  return type === String && includeInstances
+    ? item?.constructor !== CustomStringConstructor && item?.constructor !== type
+    : item?.constructor !== type;
 }
 
-function getSWInformation(notChainable) {
-  const firstLines = CustomStringConstructor(decode());
-  const plainValues = getPlainValues();
+function resolveTemplateString(str, ...args) {
+  return str?.raw
+    ? String.raw({ raw: str }, ...args)
+    : getStringValue(str).length ? str : "";
+}
 
-  return firstLines.split(/\n/)
-    .concat(
-      Object.entries(Object.getOwnPropertyDescriptors(firstLines))
-      .sort(([keyA], [keyB]) => keyA.localeCompare(keyB))
-      .map(([key, descriptr]) => {
-        const isChainable = !notChainable.find(k => k === key);
-        const isGetter = 'get' in descriptr;
-        const isMethod = 'value' in descriptr;
-        const isNative = key in String.prototype;
-        const isPlainValue = !isNative && key in plainValues;
-        const custom = key in customMethods ? ` *custom*` : ``;
-        const getter = isGetter && isChainable ? `chainable getter${custom}` : `getter`;
-        const method = isMethod && isChainable ? `chainable method${custom}` : `method`;
-        const native = isNative && `${descriptr.get ? `getter` : `method`} (override)`;
-
-        switch (true) {
-            case isPlainValue: return infoValue(key, plainValues[key]);
-            case isNative: return infoValue(key, native);
-            case isMethod: return infoValue(key, method);
-            case isGetter: return infoValue(key, getter);
-         }
-        }
-      )
-    );
+function retrieveQuotInfo(instanceQuotGetters4Info, ctor) {
+  return Object.entries(Object.getOwnPropertyDescriptors(instanceQuotGetters4Info.value))
+    .sort( (a,b) => a[0].localeCompare(b[0]) )
+    .reduce((acc, [k,]) => {
+      if (k === `remove`) { return [...acc, `[instance].quote.remove (only predefined)`]; }
+      if (k === `custom`) { return [...acc, `[instance].quote.custom(start:string, end:string)`]; }
+
+      const val = ctor(`[instance]`).quote[k];
+      return [...acc, `[instance].quote.${k} ( ${val} )`];
+    }, []);
 }
 
 function quotGetters4Instance(instance, wrap) {
@@ -138,51 +120,48 @@ function quotGetters4Instance(instance, wrap) {
   };
 }
 
-function decode() {
-  return atob`Rm9yIHRoZSByZWNvcmQ6CltjbV0gY2hhaW5hYmxlIGdldHRlcnMvbWV0aG9kcyBtb2RpZnkgdGhlIGluc3RhbmNlIHN0cmluZwpbY21dIGluZGV4T2Ygb3ZlcnJpZGVzIHJldHVybnMgW3VuZGVmaW5lZF0gaWYgbm90aGluZyB3YXMgZm91bmQgKHNvIG9uZSBjYW4gdXNlIFtsYXN0SV1pbmRleE9mKFtzb21lIHN0cmluZyB2YWx1ZV0pID8/IDAKW2NtXSBpbmNsdWRlcyBpbmZvcm1hdGlvbiBmb3IgY3VzdG9tIG1ldGhvZHMvZ2V0dGVycyBpZiBhcHBsaWNhYmxl`.replace(/\[cm]/g, `\u2714`);
-}
-
-function defineQuotingStyles() {
-  // see https://en.wikipedia.org/wiki/Quotation_mark
-  const quots = {
-    backtick: ["`", "`"],
-    parentheses: [`(`, `)`],
-    curlyBrackets: [`{`, `}`],
-    curlyDoubleInward: [`”`, `“`],
-    curlyDouble: [`“`, `”`],
-    curlyDoubleEqual: [`“`, `“`],
-    curlyLHDouble: [`„`, `”`],
-    curlyLHDoubleInward: [`„`, `“`],
-    curlyLHSingle: [`‚`, `’`],
-    curlyLHSingleInward: [`‚`, `‘`],
-    curlySingle: [`‛`, `’`],
-    curlySingleEqual: [`‛`, `‛`],
-    curlySingleInward: [`’`, `‛`],
-    double: [`"`, `"`],
-    guillemets: [`«`, `»`],
-    guillemetsInward: [`»`, `«`],
-    guillemetsSingle: [`‹`, `›`],
-    guillemetsSingleInward: [`›`, `‹`],
-    single: [`'`, `'`],
-    squareBrackets: [`[`, `]`],
-  };
-  const regExpValues = escape4RE([...new Set(
-    Object.values(quots)
-      .filter(v => Array.isArray(v))
-      .flat())].join(``));
-  quots.re = RegExp(`^[${regExpValues}]|[${regExpValues}]$`, "g");
-
-  return quots;
+function capitalizerFactory(instance, wrap) {
+  return {
+    get full() {
+      return wrap(instance.value.toUpperCase());
+    },
+    get none() {
+      return wrap(instance.value.toLowerCase());
+    },
+    get camel() {
+      return wrap(parseCamelcase(instance.value));
+    },
+    get snake() {
+      return wrap(parseSnakeCase(instance.value));
+    },
+    get first() {
+      return wrap(ucFirst(instance.value));
+    },
+    get kebab() {
+      return wrap(parseKebabCase(instance.value));
+    },
+    get words() {
+      return wrap(wordsFirstUp(instance.value));
+    },
+    get dashed() {
+      return wrap(parseKebabCase(instance.value));
+    },
+  }
 }
 
 function createExtendedCTOR(ctor, customMethods) {
-  const instanceQuotGetters4Info = quotGetters4Instance(ctor());
-  Symbol.toSB = Symbol.for(`toStringBuilder`);
-  Object.defineProperty(String.prototype, Symbol.toSB, {
-    get() { return ctor(this); },
-    enumerable: false,
-    configurable: false });
-  const notChainable =  `constructor,history,indexOf,toString,value,valueOf,empty`.split(`,`);
+  const quoteInfo = retrieveQuotInfo(quotGetters4Instance(ctor()), ctor);
+  const swInfo = getSWInformation(`constructor,history,indexOf,toString,value,valueOf,empty`.split(`,`), ctor);
+  Symbol.toSB = Symbol(`toStringBuilder`);
+  Object.defineProperty(
+    String.prototype,
+    Symbol.toSB, {
+      get() { return ctor(this); },
+      enumerable: false,
+      configurable: false
+    }
+  );
+
   Object.defineProperties(ctor, {
     create: {
       get() { return ctor(); },
@@ -210,9 +189,7 @@ function createExtendedCTOR(ctor, customMethods) {
         }
       }
     },
-    info: {
-      get() { return getSWInformation(notChainable); }
-    },
+    info: { value: swInfo, },
     keys: {
       get() {
         return Object.keys(Object.getOwnPropertyDescriptors(CustomStringConstructor``))
@@ -220,22 +197,8 @@ function createExtendedCTOR(ctor, customMethods) {
           .map(v => !/constructor|toString|valueOf/.test(v) && v in customMethods ? `${v} *custom*` : v);
       }
     },
-    quoteInfo: {
-      get() {
-        return Object.entries(Object.getOwnPropertyDescriptors(instanceQuotGetters4Info.value))
-          .sort( (a,b) => a[0].localeCompare(b[0]) )
-          .reduce((acc, [k,]) => {
-            if (k === `remove`) { return [...acc, `[instance].quote.remove (only predefined)`]; }
-            if (k === `custom`) { return [...acc, `[instance].quote.custom(start:string, end:string)`]; }
-
-            const val = ctor(`[instance]`).quote[k];
-            return [...acc, `[instance].quote.${k} ( ${val} )`];
-          }, []);
-      }
-    },
-    uuid4: {
-      get() { return CustomStringConstructor(uuid4()); }
-    },
+    quoteInfo: { value: quoteInfo },
+    uuid4: { get() { return CustomStringConstructor(uuid4()); } },
     randomString: {
       value: function({len, includeUppercase, includeNumbers, includeSymbols, startAlphabetic} = {}) {
         return CustomStringConstructor(randomString({len, includeUppercase, includeNumbers, includeSymbols, startAlphabetic}));
@@ -244,11 +207,54 @@ function createExtendedCTOR(ctor, customMethods) {
     regExp: { value: createRegExp }
   });
 
-  return ctor;
+  return;
 }
 
-function checkType(type, item, includeInstances) {
-  return type === String && includeInstances
-    ? item?.constructor !== CustomStringConstructor && item?.constructor !== type
-    : item?.constructor !== type;
+function getSWInformation(notChainable, customMethods) {
+  const firstLines = CustomStringConstructor(getInfoPrefix());
+  const plainValues = getPlainValues();
+
+  return firstLines.split(/\n/)
+    .concat(
+      Object.entries(Object.getOwnPropertyDescriptors(firstLines))
+        .sort(([keyA], [keyB]) => keyA.localeCompare(keyB))
+        .map(([key, descriptr]) => {
+            const isChainable = !notChainable.find(k => k === key);
+            const isGetter = 'get' in descriptr;
+            const isMethod = 'value' in descriptr;
+            const isNative = key in String.prototype;
+            const isPlainValue = !isNative && key in plainValues;
+            const custom = key in customMethods ? ` *custom*` : ``;
+            const getter = isGetter && isChainable ? `chainable getter${custom}` : `getter`;
+            const method = isMethod && isChainable ? `chainable method${custom}` : `method`;
+            const native = isNative && `${descriptr.get ? `getter` : `method`} (override)`;
+
+            switch (true) {
+              case isPlainValue: return infoValue(key, plainValues[key]);
+              case isNative: return infoValue(key, native);
+              case isMethod: return infoValue(key, method);
+              case isGetter: return infoValue(key, getter);
+            }
+          }
+        )
+    );
+}
+
+function getPlainValues() {
+  const capitalizerKeys = Object.keys(capitalizerFactory());
+  return {
+    value: `getter/setter`,
+    clone: `chainable getter`,
+    notEmpty: `chainable getter|undefined`,
+    quote: `Object. See [constructor].quoteInfo`,
+    capitalize: `getter. Object with chainable getters: [${capitalizerKeys.join(`, `)}]`,
+  };
+}
+
+function getInfoPrefix() {
+  return atob(
+    `Rm9yIHRoZSByZWNvcmQ6CltjbV0gY2hhaW5hYmxlIGdldHRlcnMvbWV0aG9kcyBtb2RpZnkgdGhlIGluc3RhbmNlIHN0cmluZwpbY21d`+
+    `IGluZGV4T2Ygb3ZlcnJpZGVzIHJldHVybnMgW3VuZGVmaW5lZF0gaWYgbm90aGluZyB3YXMgZm91bmQgKHNvIG9uZSBjYW4gdXNlIFtsYXN0`+
+    `SV1pbmRleE9mKFtzb21lIHN0cmluZyB2YWx1ZV0pID8/IDAKW2NtXSBpbmNsdWRlcyBpbmZvcm1hdGlvbiBmb3IgY3VzdG9tIG1ldGhv`+
+    `ZHMvZ2V0dGVycyBpZiBhcHBsaWNhYmxl`).replace(/\[cm]/g, `\u2714`);
 }

package/src/{extensions.js → instanceCreator.js}

@@ -20,12 +20,11 @@ import {
   isNumber,
   clone,
   trim,
-  capitalizerFactory,
 } from "./instanceMethods.js";
 
-export default instanceCreator;
+import { capitalizerFactory, deprecatedRE } from "./helpers.js";
 
-const deprecatedRE = /symbol|anchor|big|blink|bold|fixed|fontsize|fontcolor|italics|link|small|strike|sup|sub/i
+export default instanceCreator;
 
 function instanceCreator({initialstring} = {}) {
   let customStringExtensions = { };

package/src/instanceMethods.js

@@ -1,13 +1,9 @@
+import { customMethods, clone, } from "./CTORCreator.js";
+
 import {
-  isArrayOf,
-  isNumber,
-  quotGetters4Instance as quotGetters,
-  getStringValue,
-  escapeRE,
-  customMethods,
-  interpolate,
-  createRegExp as $RE,
-  clone } from "./genericMethods.js";
+  createRegExp as $RE, getStringValue, isArrayOf, interpolate,
+  isNumber, escapeRE, quotGetters4Instance as quotGetters,
+} from "./helpers.js";
 
 export {
   format,
@@ -30,7 +26,6 @@ export {
   surroundWith,
   customMethods,
   clone,
-  capitalizerFactory,
   trim,
 };
 
@@ -215,32 +210,3 @@ function append(string, ...strings2Append) {
 
   return getStringValue(string);
 }
-
-function capitalizerFactory(instance, wrap) {
-  return {
-    get full() {
-      return wrap(instance.value.toUpperCase());
-    },
-    get none() {
-      return wrap(instance.value.toLowerCase());
-    },
-    get camel() {
-      return wrap(parseCamelcase(instance.value));
-    },
-    get snake() {
-      return wrap(parseSnakeCase(instance.value));
-    },
-    get first() {
-      return wrap(ucFirst(instance.value));
-    },
-    get kebab() {
-      return wrap(parseKebabCase(instance.value));
-    },
-    get words() {
-      return wrap(wordsFirstUp(instance.value));
-    },
-    get dashed() {
-      return wrap(parseKebabCase(instance.value));
-    },
-  }
-}