stringweaver 1.0.0

package/Bundle/index.min.js

@@ -0,0 +1,6 @@
+/*© KooiInc 2025-2030*/
+var D=le();function le(e=""){return e=e?.constructor===String?e:"",function(s,...p){return j(s,$(p))};function t(s,p){return p&&e.length>0?String(e):`{${s}}`}function r(s){return s?.constructor===String||s?.constructor===Number&&!Number.isNaN(s)}function o(s,p){let b=s in p;return b&&r(p[s])?String(p[s]):t(s,b)}function n(s){return(...p)=>{let b=p.find(g=>g.key);return o(b?b.key:"_",s)}}function i(s,p){return s.replace(/\{(?<key>[a-z_\d]+)}/gim,n(p))}function c(s){let p=[];return Object.entries(s).forEach(([b,g])=>{g.forEach((A,u)=>(p[u]??={},p[u][b]=A))}),p}function y(s){return s.length===1&&Object.values(s[0]).every(Array.isArray)}function $(s){return y(s)?c(s[0]):s}function j(s,p){return p?.length?p.filter(b=>b).map(b=>b?.constructor===Object?i(s,b):"").join(""):s}}var{randomString:H,uuid4:F}=ie();function ie(){let e=g(),t=()=>e?[...crypto.getRandomValues(new Uint32Array(1))].shift()/2**32:Math.random(),r=({min:l=0,max:a=Number.MAX_SAFE_INTEGER}={})=>Math.floor(t()*(a-l+1)+l),o=(l=0,a=10,d)=>(d||[])instanceof Function?[...Array(a)].map((w,x)=>l+x).map(d):[...Array(a)].map((w,x)=>l+x),n=l=>String.fromCharCode(l),i="!?@#$%^&*=+_;-".split(""),c=RegExp(`[${i.map(l=>`\\${l}`).join("")}]`,"g"),y=l=>{let a=l.length;for(;a--;){let d=r({max:a});[l[a],l[d]]=[l[d],l[a]]}return l},$=y(o(65,26,n)),j=y(o(97,26,n)),p={UCLC:y($.concat(j)),UC:$,LC:j,Nrs:y(o()),Sym:y(i)},b=l=>Object.entries(l).reduce((a,[d,w])=>w?[...a,...p[d]]:a,j);function g(){try{return window&&"crypto"in window}catch{return!1}}function A(){return e&&crypto.randomUUID?crypto.randomUUID():[...new Uint8Array(16)].map(l=>r({max:255})).map((l,a)=>`${(a===8?l&63|128:a===6?l&15|64:l).toString(16).padStart(2,"0")}${~[3,5,7,9].indexOf(a)?"-":""}`).join("")}function u(l,a,d){return/[a-z]/i.test(l)&&(a&&d?/\d/.test(l)&&c.test(l):a?/\d/.test(l):d?c.test(l):!0)}function m(l){let a=[...l],d=a.findIndex(w=>/[a-z]/i.test(w));return[a[0],a[d]]=[a[d],a[0]],a.join("")}function S({len:l=12,includeUppercase:a=!0,includeNumbers:d,includeSymbols:w,startAlphabetic:x}={}){l=l<6?6:l;let O=y(b({UC:a,Nrs:d,Sym:w}));for(;O.length<l;)O=[...O,...y(O)];let v=O.slice(0,l).join("");if(!(d||w))return v;for(let G=0;G<O.length;G+=1)if(v=O.slice(G,G+l).join(""),u(v,d,w))return x&&!/^[a-z]/i.test(v)?m(v):v;return S({len:l,includeUppercase:a,includeNumbers:d,includeSymbols:w,startAlphabetic:x})}return{randomString:S,uuid4:A}}var _=ae;function ae(e,...t){t=e.raw?t:[t];try{return se(e,...t)}catch(r){let o=T();return`Error creating Regular Expression from string "${e.raw||e}" with flags ${o}
+RegExp error message: "${r.message}"`}}function T(...e){return e.length>0?Array.isArray(e.slice(-1))?e.pop().join(""):e.join(""):""}function se(e,...t){let r=T(...t);t=[];let o=e.raw||[e];return new RegExp((t.length&&o.reduce((n,i,c)=>n.concat(t[c-1]||"").concat(i),"")||o?.join("")).split(`
+`).map(n=>n.replace(/\s|\/\/.*$/g,"").trim().replace(/(@s!)/g," ")).join(""),r)}function z(e,...t){return e.raw?String.raw({raw:e},...t):e}function f(e){return e?.value||e?.constructor===String&&e||""}function ge(e,t,r){return e===String&&r?t?.constructor!==U&&t?.constructor!==e:t?.constructor!==e}function E(e,t,r=!0){return Array.isArray(t)&&t.length>0&&!t.find(o=>ge(e,o,r))}function L(e){return e?.constructor===Number&&!Number.isNaN(e)}function B(e){return/wrap\(|undo.*/i.test(e.toString())}function fe(){let e=C(pe());return e.value.split(/\n/).concat(Object.entries(Object.getOwnPropertyDescriptors(e)).map(([t,r])=>t==="quote"?"quote (Object. See [constructor].quoteInfo)":`${t} (${t==="value"?"getter/setter":t==="clone"?"chainable getter":t in String.prototype?"method, String override":r.value&&r.value.constructor===Function?B(r.value)?`chainable method${t in R?" *custom*":""}`:"method":r.value?"property":r.get?B(r.get)?`chainable getter${t in R?" *custom*":""}`:"getter":"-"})`).sort((t,r)=>t.localeCompare(r)))}function k(e,t){return Object.defineProperties(e,{constructor:{get(){return e},enumerable:!1},format:{value(r,...o){return C(r).format(...o)}},addCustom:{value({name:r,method:o,enumerable:n=!1,isGetter:i=!1}={}){if(C``[r])return console.error(`addCustom: the property "${r}" exists and can not be redefined`);r?.constructor===String&&o?.constructor===Function&&o.length>0&&(t[r]={method:o,enumerable:n,isGetter:i})}},info:{get(){return fe()}},keys:{get(){return Object.keys(Object.getOwnPropertyDescriptors(C``)).sort((r,o)=>r.localeCompare(o)).map(r=>!/constructor|toString|valueOf/.test(r)&&r in t?`${r} *custom*`:r)}},quoteInfo:{get(){let r={...N()};return delete r.re,Object.entries(r).sort((o,n)=>o[0].localeCompare(n[0])).reduce((o,[n,i])=>{let c=i.constructor===Function?"(start:string[, end:string])":` (${i.join(" [instance value] ")})`;return[...o,`[instance].quote.${n}${c}`]},[])}},uuid4:{get(){return F()}},randomString:{value:function({len:r,includeUppercase:o,includeNumbers:n,includeSymbols:i,startAlphabetic:c}={}){return C(H({len:r,includeUppercase:o,includeNumbers:n,includeSymbols:i,startAlphabetic:c}))}},regExp:{value:_}}),e}function M(e,t){return new RegExp(e.replace(/\p{S}|\p{P}/gu,r=>`\\${r}`),t)}function pe(){return atob`Rm9yIHRoZSByZWNvcmQ6CltjbV0gY2hhaW5hYmxlIGdldHRlcnMvbWV0aG9kcyBtb2RpZnkgdGhlIGluc3RhbmNlIHN0cmluZwpbY21dIGluZGV4T2Ygb3ZlcnJpZGVzIHJldHVybiBbdW5kZWZpbmVkXSBpZiBub3RoaW5nIHdhcyBmb3VuZCAoc28gb25lIGNhbiB1c2UgW2xhc3RJXWluZGV4T2YoW3NvbWUgc3RyaW5nIHZhbHVlXSkgPz8gMApbY21dIGluY2x1ZGVzIGluZm9ybWF0aW9uIGZvciBjdXN0b20gbWV0aG9kcy9nZXR0ZXJzIGlmIGFwcGxpY2FibGU=`.replace(/\[cm\]/g,"\u2714")}function N(){let t={backtick:["`","`"],bracket:["{","}"],curlyDoubleInward:["\u201D","\u201C"],curlyDouble:["\u201C","\u201D"],curlyDoubleEqual:["\u201C","\u201C"],curlyLHDouble:["\u201E","\u201D"],curlyLHDoubleInward:["\u201E","\u201C"],curlyLHSingle:["\u201A","\u2019"],curlyLHSingleInward:["\u201A","\u2018"],curlySingle:["\u201B","\u2019"],curlySingleEqual:["\u201B","\u201B"],curlySingleInward:["\u2019","\u201B"],custom:(o,n)=>(o=f(o),n=f(n),[f(o),n.length?n:o]),double:['"','"'],guillemets:["\xAB","\xBB"],guillemetsInward:["\xBB","\xAB"],guillemetsSingle:["\u2039","\u203A"],guillemetsSingleInward:["\u203A","\u2039"],single:["'","'"],squareBrackets:["[","]"]},r=Object.values(t).filter(o=>Array.isArray(o)).map(o=>o.map(n=>`\\${n}`).join("")).join("");return t.re=RegExp(`^[${r}]|[${r}]$`,"g"),t}var h=N();function I(e,t,r){return e=f(e),e.length>0?t(e):r||e}function V(e,...t){return I(e,()=>`${D(e,...t)}`)}function W(e){return I(e,()=>`${e[0].toUpperCase()}${e.slice(1)}`)}function P(e,t,r){return!t&&!r?e:([t,r]=E(String,[t,r??""])?[t,r]:["",""],`${t}${e}${r||t}`)}function Y(e){return I(e,()=>e.replace(/\s/g,"").replace(/[A-Z]/g,t=>`-${t.toLowerCase()}`).replace(/-{2,}/g,"-").replace(/[^a-z-]/g,"").replace(/^-|-$/,""))}function X(e){return I(e,()=>e.replace(/\s/g,"").replace(/[A-Z]/g,t=>`_${t.toLowerCase()}`).replace(/_{2,}/g,"_").replace(/[^a-z_]/g,"").replace(/^_|_$/,""))}function J(e){return I(e,()=>[...e.toLowerCase()].slice(1).reduce((t,r)=>t+(/\p{L}|[-']/u.test(t.at(-1))?r.toLowerCase():r.toUpperCase()),e[0].toUpperCase()))}function Q(e){return I(e,()=>e.toLowerCase().trim().split(/[- ]/).filter(t=>t&&t.length>0).map((t,r)=>r>0&&`${W(t)}`||t).join(""))}function K(e,{at:t,html:r=!1,wordBoundary:o=!1}={}){return I(e,()=>{if(e.length<=t)return e;let n=e.slice(0,t-1),i=r?"&hellip;":"...",c=o?[...n.matchAll(/\p{Pe}|\p{Z}/gu)].at(-1)?.index??n.length:n.length;return(o?n.slice(0,c+1).trim():n)+i})}function Z(e,t){return I(e,()=>{let r=e.split(/\n/).map(o=>o.trim().replace(/\s{2,}/g," "));return t?r.join(`
+`):r.filter(o=>o.length>0).join(`
+`)})}function ee(e,{replacements:t={},caseSensitive:r=!1}={}){e=f(e);let o=Object.entries(t).flat(),n=E(String,o)&&r?.constructor===Boolean,i=`g${r?"":"i"}`;if(n&&(o=o.map(c=>f(c)).filter(c=>o.length>0),o.length))for(;o.length;){let[c,y]=[o.shift(),o.shift()],$=M(c,i);e=e.replace($,y)}return e}function te(e,t,r){e=f(e),r=L(r)?r:0;let o=e.indexOf(t,r||0);return o<0?void 0:o}function re(e,t,r){e=f(e),r=L(r)?r:e.length;let o=e.lastIndexOf(t,r);return o<0?void 0:o}function q(e,{value:t,values:r,at:o=0}={}){e=f(e),o=L(o)?o:0;let n=f(r);return r=f(t).length?t:n.length?n:E(String,r)?r.map(i=>f(i)).join(""):[],r.length<=1?e:e.length===0?`${r}${e}`:`${e.slice(0,o)}${r}${e.slice(o)}`}function ne(e,...t){return t=E(String,t)&&t,t?q(f(e),{values:t,at:0}):f(e)}function oe(e,...t){return t=E(String,t)&&t,t&&t.length>0?`${f(e)}`.concat(t.join("")):f(e)}function ue(e,t){return{value:{get backtick(){return e.enclose(...h.backtick)},get bracket(){return e.enclose(...h.bracket)},get curlyDouble(){return e.enclose(...h.curlyDouble)},get curlyDoubleInward(){return e.enclose(...h.curlyDoubleInward)},get curlyDoubleEqual(){return e.enclose(...h.curlyDoubleEqual)},get curlyLHDoubleInward(){return e.enclose(...h.curlyLHDoubleInward)},get curlyLHSingle(){return e.enclose(...h.curlyLHSingle)},get curlyLHSingleInward(){return e.enclose(...h.curlyLHSingleInward)},get curlySingle(){return e.enclose(...h.curlySingle)},get curlySingleEqual(){return e.enclose(...h.curlySingleEqual)},get curlySingleInward(){return e.enclose(...h.curlySingleInward)},custom(r,o){return e.enclose(r,o??r)},get double(){return e.enclose(...h.double)},get guillemets(){return e.enclose(...h.guillemets)},get guillemetsInward(){return e.enclose(...h.guillemetsInward)},get guillemetsSingle(){return e.enclose(...h.guillemetsSingle)},get guillemetsSingleInward(){return e.enclose(...h.guillemetsSingleInward)},get remove(){return t(`${e.value.replace(h.re,"")}`)},get single(){return e.enclose(...h.single)},get squareBrackets(){return e.enclose(...h.squareBrackets)}},enumerable:!1}}var ce=me;function me({initialstring:e,customMethods:t}={}){let r={},o=new Proxy(r,y(r)),n=e?.constructor===String?e:"",i=[n],c=!1;return Object.defineProperties(r,{append:{value(...u){return g(oe(n,...u))},enumerable:c},enclose:{value(u,m){return g(P(n,u,m))},enumerable:c},format:{value(...u){return g(V(n,...u))},enumerable:c},indexOf:{value(u){return te(n,u)},enumerable:c},interpolate:{value(...u){return g(V(n,...u))},enumerable:c},insert:{value({value:u,values:m,at:S}={}){return g(q(n,{value:u,values:m,at:S}))},enumerable:c},lastIndexOf:{value(u){return re(n,u)},enumerable:c},prefix:{value(...u){return g(ne(n,...u))},enumerable:c},replaceWords:{value({caseSensitive:u=!1,replacements:m={}}={}){return g(ee(n,{replacements:m,caseSensitive:u}))},enumerable:c},toString:{value(){return n},enumerable:c},truncate:{value({at:u,html:m=!1,wordBoundary:S=!1}={}){return g(K(n,{at:u,html:m,wordBoundary:S}))},enumerable:c},valueOf:{value(){return n},enumerable:c},undoLast:{value(u){return p(u)},enumerable:c},camelCase:{get(){return g(Q(f(n)))},enumerable:c},clone:{get(){return $()},enumerable:c},constructor:{get(){return C.constructor},enumerable:c},kebabCase:{get(){return g(Y(f(n)))},enumerable:c},firstUp:{get(){return g(W(f(n)))},enumerable:c},history:{get(){return i},set(u){i=u},enumerable:c},quote:ue(o,g),snakeCase:{get(){return g(X(f(n)))}},trimAll:{get(){return g(Z(n))},enumerable:c},trimAllKeepLF:{get(){return g(Z(n,!0))},enumerable:c},undoAll:{get(){return s()},enumerable:c},undo:{get(){return b()},enumerable:c},wordsUCFirst:{get(){return g(J(f(n)))},enumerable:c},value:{get(){return n},set(u){n=f(u).length?u:n,i.push(n)},enumerable:c}}),A(t),Object.freeze(o);function y(u){return{get(m,S){return S in u?u[S]:S in String.prototype?j(S):void 0}}}function $(){let u=C(n);return u.history=[...i],u}function j(u){return n[u]instanceof Function?function(...m){let S=n[u](...m);return S?.constructor===String?g(n[u](...m)):S}:n[u]}function s(){for(;i.length>1;)i.pop();return n=i.at(-1),g(n,!1)}function p(u){if(!L(u))return g(n,!1);let m=i.length;return u>=m||u<1?(i=i.slice(0,1),n=i.at(-1),g(i.at(-1),!1)):(i=i.slice(0,m-u),n=i.at(-1),g(n,!1))}function b(){return i.length===1?g(i[0]):(i.pop(),n=i.at(-1),g(n,!1))}function g(u,m=!0){return n!==u&&m&&i.push(u),n=u,o}function A(u){Object.entries(u).forEach(([m,S])=>{let{enumerable:l,method:a,isGetter:d}=S;Object.defineProperty(r,m,d?{get(){return g(a(o).value)},enumerable:l}:{value(...x){return g(a(o,...x).value)},enumerable:l})})}}var R={},C=k(U,R);function U(e,...t){return ce({initialstring:z(e,...t),customMethods:R})}export{U as CustomStringConstructor,R as customMethods,C as default};

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Renzo Kooi
+
+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,5 @@
+## js-stringweaver
+
+A "stringbuilder" library
+
+<a target="_blank" href="https://kooiinc.github.io/js-stringweaver/Examples">Examples</a>

package/index.js

@@ -0,0 +1,11 @@
+import createInstance from "./src/extensions.js";
+import { resolveTemplateString as resolveString, createExtendedCTOR } from "./src/genericMethods.js";
+
+const customMethods = {};
+const defaultStringCTOR = createExtendedCTOR(CustomStringConstructor, customMethods);
+
+export {defaultStringCTOR as default, CustomStringConstructor, customMethods};
+
+function CustomStringConstructor(str, ...args) {
+  return createInstance({initialstring: resolveString(str, ...args), customMethods});
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "stringweaver",
+  "type": "module",
+  "version": "1.0.0",
+  "private": false,
+  "main": "./index.js",
+  "description": "A JS stringbuilder utility",
+  "keywords": [
+    "JS",
+    "ES20xx",
+    "String",
+    "Stringbuilder",
+    "String",
+    "Utilities",
+    "Classfree Object Oriented"
+  ],
+  "author": "KooiInc",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/KooiInc/js-stringweaver"
+  },
+  "devDependencies": {
+    "esbuild": "latest"
+  },
+  "bugs": {
+    "url": "https://github.com/KooiInc/js-stringweaver/issues"
+  }
+}

package/src/Factories/interpolateFactory.js

@@ -0,0 +1,125 @@
+const defaultInterpolator = interpolateFactory();
+export {defaultInterpolator as default, interpolateFactory};
+
+/**
+ * Factory function to create an interpolate function with a default replacer.
+ * @param {string} defaultReplacer - Default value to use for missing tokens.
+ * @returns {Function} - The interpolation function.
+ */
+function interpolateFactory(defaultReplacer = "") {
+  defaultReplacer = defaultReplacer?.constructor === String ? defaultReplacer : "";
+  
+  /**
+   * Main interpolation function.
+   * @param {string} str - The string with placeholders.
+   * @param {...object} tokens - Objects containing replacement values.
+   * @returns {string} - The interpolated string.
+   */
+  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.
+   * @param {boolean} keyExists - Flag indicating if the key exists in the token.
+   * @returns {string} - The replacement value.
+   */
+  function invalidate(key, keyExists) {
+    if (keyExists && defaultReplacer.length > 0) {
+      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.
+   * @param {object} token - The token object containing replacement values.
+   * @returns {string} - The replacement value.
+   */
+  function replacement(key, token) {
+    const isValid = key in token;
+    return isValid && isStringOrNumber(token[key]) ? String(token[key]) : invalidate(key, isValid);
+  }
+  
+  /**
+   * Create a lambda function for replacing placeholders in the string.
+   * @param {object<string, string>} token - The token object containing replacement values.
+   * @returns {Function} - The replacer lambda function.
+   */
+  function getReplacerLambda(token) {
+    return (...args) => {
+      const replacementObject = args.find(a => a.key);
+      return replacement((replacementObject ? replacementObject.key : `_`), token);
+    };
+  }
+  
+  /**
+   * Replace placeholders in the string with values from the token.
+   * @param {string} str - The string with placeholders.
+   * @param {object} token - The token object containing replacement values.
+   * @returns {string} - The interpolated string.
+   */
+  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.
+   */
+  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.
+   * @returns {boolean} - True if tokens contains one Object
+   *  and all it's values are of type Array.
+   */
+  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.
+   * @returns {object[]} - Processed tokens.
+   */
+  function processTokens(tokens) {
+    return isMultiLineWithArrays(tokens) ? convertTokensFromArrayValues(tokens[0]) : tokens;
+  }
+  
+  /**
+   * Interpolate the string with the given tokens.
+   * @param {string} str - The string with placeholders.
+   * @param {object[]} tokens - The tokens containing replacement values.
+   * @returns {string} - The interpolated string.
+   */
+  function interpolate(str, tokens) {
+    return !tokens?.length ? str : tokens
+      .filter(token => token)
+      .map(token => token?.constructor === Object ? replace(str, token) : ``)
+      .join(``);
+  }
+}

package/src/Factories/randomStringFactory.js

@@ -0,0 +1,87 @@
+const { randomString, uuid4 } = randomStringGeneratorFactory();
+export { randomString as default, randomString, uuid4 };
+
+function randomStringGeneratorFactory() {
+  const hasCrypto = checkBrowserCrypto();
+  const getRandomValue = () => hasCrypto
+    ? [...crypto.getRandomValues(new Uint32Array(1))].shift() / 2**32
+    : Math.random();
+  const randomNr = ({min = 0, max = Number.MAX_SAFE_INTEGER} = {}) =>
+    Math.floor( getRandomValue() * (max - min + 1) + min );
+  const range = (start = 0, len = 10, reMap) => (reMap || []) instanceof Function
+    ? [...Array(len)].map((_, i) => start + i).map(reMap)
+    : [...Array(len)].map((_, i) => start + i);
+  const map2Chrs = v => String.fromCharCode(v);
+  const symbols = `!?@#$%^&*=+_;-`.split(``);
+  const symRE = RegExp(`[${symbols.map(v => `\\${v}`).join(``)}]`, `g`);
+  const shuffle = array => {
+    let i = array.length;
+    while (i--) {
+      const ri = randomNr( { max: i } );
+      [array[i], array[ri]] = [array[ri], array[i]];
+    }
+    
+    return array;
+  };
+  const UC = shuffle(range(65, 26, map2Chrs));
+  const LC = shuffle(range(97, 26, map2Chrs));
+  const UCLC = shuffle(UC.concat(LC));
+  const allChars = { UCLC, UC, LC, Nrs: shuffle(range()), Sym: shuffle(symbols), };
+  const getChars2Use =  use => Object.entries(use)
+    .reduce( (acc, [key, value]) => value ? [...acc, ...allChars[key]] : acc, LC );
+  
+  function checkBrowserCrypto() {
+    try { return window && `crypto` in window }
+    catch(_) { return false; }
+  }
+  
+  function uuid4() {
+    // Note: randomUUID only in secure context (https)
+    return hasCrypto && crypto.randomUUID
+      ? crypto.randomUUID()
+      : [...new Uint8Array(16)]
+        .map(_ => randomNr({max: 255}))
+        .map( (v, i) => `${
+          (i === 8 ? v & 0b00111111 | 0b10000000 : i === 6  ? v & 0b00001111 | 0b01000000 : v)
+            .toString(16).padStart(2, `0`)}${~[3,5,7,9].indexOf(i) ? `-` : ``}` )
+        .join(``);
+  }
+  
+  function strTest(strFound, numbers, symbols) {
+    return /[a-z]/i.test(strFound) && (
+      numbers && symbols ? /\d/.test(strFound) && symRE.test(strFound)
+        : numbers ? /\d/.test(strFound)
+          : symbols ? symRE.test(strFound)
+            : true);
+  }
+  
+  function alphaSwap(strFound) {
+    const chars = [...strFound];
+    const idx = chars.findIndex(v => /[a-z]/i.test(v));
+    [chars[0], chars[idx]] = [chars[idx], chars[0]];
+    return chars.join(``);
+  }
+  
+  function randomString( {len = 12, includeUppercase = true, includeNumbers, includeSymbols, startAlphabetic} = {} ) {
+    len = len < 6 ? 6 : len;
+    let chrs2Use = shuffle( getChars2Use( { UC: includeUppercase, Nrs: includeNumbers, Sym: includeSymbols } ) );
+    
+    while (chrs2Use.length < len) { chrs2Use = [...chrs2Use, ...shuffle(chrs2Use)]; }
+    
+    let strFound = chrs2Use.slice(0, len).join(``);
+    
+    if (!(includeNumbers || includeSymbols)) { return strFound; }
+    
+    for (let i = 0; i < chrs2Use.length; i += 1) {
+       strFound = chrs2Use.slice(i, i + len).join(``);
+    
+      if (strTest(strFound, includeNumbers, includeSymbols)) {
+        return startAlphabetic && !/^[a-z]/i.test(strFound) ? alphaSwap(strFound) : strFound;
+      }
+    }
+    
+    return randomString({len, includeUppercase, includeNumbers, includeSymbols, startAlphabetic});
+  }
+  
+  return { randomString, uuid4 };
+}

package/src/Factories/regExpFromMultilineStringFactory.js

@@ -0,0 +1,35 @@
+import {resolveTemplateString} from "../genericMethods.js";
+
+export default createRegExp
+
+function createRegExp(str, ...args) {
+  args = !str.raw ? [args] : args;
+  try {
+    return regExp(str, ...args);
+  } catch (err) {
+    const flags = resolveFlags();
+    const raw = str.raw || str; 
+    return `Error creating Regular Expression from string "${raw}" with flags ${flags}` +
+      `\nRegExp error message: "${err.message}"`;
+  }
+}
+
+function resolveFlags(...args) {
+  return args.length > 0
+    ? Array.isArray(args.slice(-1))
+      ? args.pop().join(``) : args.join(``) : ``;
+}
+
+function regExp(regexStr, ...args) {
+  const flags = resolveFlags(...args);
+  args = [];
+  const raw = regexStr.raw || [regexStr];
+  
+  return new RegExp(
+    (args.length &&
+      raw.reduce( (a, v, i ) => a.concat(args[i-1] || ``).concat(v), ``) ||
+      raw?.join(``))
+      .split(`\n`)
+      .map( line => line.replace(/\s|\/\/.*$/g, ``).trim().replace(/(@s!)/g, ` `) )
+      .join(``), flags);
+}

package/src/extensions.js

@@ -0,0 +1,144 @@
+import {
+  format, ucFirst, truncate, trimAll, replaceWords,
+  indexOf, lastIndexOf, insert, append, prefix,
+  getStringValue, quotGetters, surroundWith,
+  toCamelcase, wordsFirstUp, toDashedNotation, toSnakeCase,
+} from "./instanceMethods.js";
+
+import {xString as $S, isNumber} from "./genericMethods.js";
+export default instanceCreator;
+
+function instanceCreator({initialstring, customMethods} = {}) {
+  let customStringExtensions = { };
+  let instance = new Proxy(customStringExtensions, getTraps(customStringExtensions));
+  let actualValue = initialstring?.constructor === String ? initialstring : ``;
+  let history = [actualValue];
+  const enumerable = false;
+  
+  Object.defineProperties(customStringExtensions, { 
+    append: { value(...strings) { return wrap(append(actualValue, ...strings)); }, enumerable },
+    enclose: { value(start, end) { return wrap(surroundWith(actualValue, start, end)); }, enumerable },
+    format: { value(...tokens) { return wrap(format(actualValue, ...tokens)); }, enumerable },
+    indexOf: { value(str) { return indexOf(actualValue, str); }, enumerable },
+    interpolate: { value(...tokens) { return wrap(format(actualValue, ...tokens)); }, enumerable },
+    insert: { value({ value, values, at } = {}) { 
+        return wrap(insert(actualValue, { value, values, at })); 
+      }, enumerable 
+    },
+    lastIndexOf: { value(str) { return lastIndexOf(actualValue, str); }, enumerable },
+    prefix: { value(...strings) { return wrap(prefix(actualValue, ...strings)); }, enumerable },
+    replaceWords: { value({caseSensitive = false, replacements = {}} = {}) {
+      return wrap(replaceWords(actualValue, {replacements, caseSensitive}));
+    }, enumerable },
+    toString: { value() { return actualValue; }, enumerable },
+    truncate: { value({at, html = false, wordBoundary = false} = {}) {
+      return wrap(truncate(actualValue, {at, html, wordBoundary})); }, enumerable },
+    valueOf: { value() { return actualValue; }, enumerable },
+    undoLast: { value(nSteps) { return undoSteps(nSteps); }, enumerable },
+
+    camelCase: { get() { return wrap(toCamelcase(getStringValue(actualValue))); }, enumerable },    
+    clone: { get() { return clone(); }, enumerable },
+    constructor: { get() { return $S.constructor; }, enumerable },
+    kebabCase: { get() { return wrap(toDashedNotation(getStringValue(actualValue))); }, enumerable },
+    firstUp: { get() { return wrap(ucFirst(getStringValue(actualValue))); }, enumerable },
+    history: { 
+      get() { return history; },
+      set(value) { history = value; },
+      enumerable },
+    quote: quotGetters(instance, wrap),
+    snakeCase: { get() { return wrap(toSnakeCase(getStringValue(actualValue))); } },
+    trimAll: { get() { return wrap(trimAll(actualValue)); }, enumerable },
+    trimAllKeepLF: { get() { return wrap(trimAll(actualValue, true)); }, enumerable },
+    undoAll: { get() { return undoAll(); }, enumerable },
+    undo: { get() { return undoLast(); }, enumerable },
+    wordsUCFirst: { get() { return wrap(wordsFirstUp(getStringValue(actualValue))); }, enumerable },
+    value: { 
+      get() { return actualValue; }, 
+      set(value) { 
+        actualValue = getStringValue(value).length ? value : actualValue;
+        history.push(actualValue);
+      }, enumerable },
+  });
+  
+  injectCustomMethods(customMethods);
+  
+  return Object.freeze(instance);
+  
+  function getTraps(extensions) {
+    return {
+      get( target, key ) {
+        return key in extensions
+          ? extensions[key]
+          : key in String.prototype
+            ? wrapNative(key)
+            : undefined;
+      },
+    };
+  }
+  
+  function clone() {
+    const newInstance = $S(actualValue);
+    newInstance.history = [...history];
+    return newInstance;
+  }
+  
+  function wrapNative(key) {
+    return actualValue[key] instanceof Function
+      ? function(...args) {
+        const result = actualValue[key](...args); 
+        return result?.constructor === String ? wrap(actualValue[key](...args)) : result; 
+      } : actualValue[key];
+  }
+  
+  function undoAll() {
+    while(history.length > 1) { history.pop(); }
+    actualValue = history.at(-1);
+    return wrap(actualValue, false);
+  }
+  
+  function undoSteps(steps) {
+    if (!isNumber(steps)) {
+      return wrap(actualValue, false); 
+    }
+    
+    const historyLen = history.length;
+    
+    if (steps >= historyLen || steps < 1) {
+      history = history.slice(0, 1);
+      actualValue = history.at(-1); 
+      return wrap(history.at(-1), false);  
+    }
+    
+    history = history.slice(0, historyLen - steps);
+    
+    actualValue = history.at(-1);
+    return wrap(actualValue, false);
+  }
+  
+  function undoLast() {
+    if (history.length === 1) {
+      return wrap(history[0]);
+    }
+    history.pop();
+    actualValue = history.at(-1);
+    return wrap(actualValue, false);
+  }
+  
+  function wrap(result, pushHistory = true) {
+    const changed = actualValue !== result;
+    changed && pushHistory && history.push(result);
+    actualValue = result;
+    return instance;
+  }
+  
+  function injectCustomMethods(customMethods) {
+    Object.entries(customMethods).forEach(([methodName, methodContainer]) => {
+      const {enumerable, method, isGetter} = methodContainer;
+      const descriptor = isGetter
+        ? { get() { return wrap(method(instance).value); }, enumerable }
+        : { value(...args) { return wrap(method(instance, ...args).value); }, enumerable, };
+      
+      Object.defineProperty(customStringExtensions, methodName, descriptor);
+    });
+  }
+}

package/src/genericMethods.js

@@ -0,0 +1,163 @@
+import xString, {CustomStringConstructor, customMethods} from "../index.js";
+import {default as randomString, uuid4}  from "./Factories/randomStringFactory.js";
+import createRegExp from "./Factories/regExpFromMultilineStringFactory.js";
+
+export {
+  createExtendedCTOR, 
+  resolveTemplateString, 
+  xString, 
+  isNumber, 
+  isArrayOf,
+  defineQuotingStyles,
+  getStringValue,
+  escapeRE,
+};
+
+function resolveTemplateString(str, ...args) {
+  return str.raw ?  String.raw({ raw: str }, ...args) : str;
+}
+
+function getStringValue(string) {
+  return string?.value || (string?.constructor === String && string) || ``;
+}
+
+function checkType(type, item, includeInstances) {
+  return type === String && includeInstances
+    ? item?.constructor !== CustomStringConstructor && item?.constructor !== type
+    : item?.constructor !== type;
+}
+
+function isArrayOf(type, value, includeInstances = true) {
+  return Array.isArray(value) && value.length > 0 && !value.find(v => checkType(type, v, includeInstances));
+}
+
+function isNumber(value) {
+  return value?.constructor === Number && !Number.isNaN(value);
+}
+
+function isMutating(descriptor) {
+  return /wrap\(|undo.*/i.test(descriptor.toString())
+}
+ 
+function getSWInformation() {
+  const firstLines = xString(decode());
+  return firstLines.value.split(/\n/).concat(
+    Object.entries(Object.getOwnPropertyDescriptors(firstLines))
+    .map(([key, descriptr]) => {
+      if (key === `quote`) { return `quote (Object. See [constructor].quoteInfo)`; }
+      return `${key} (${
+        key === `value` 
+          ? `getter/setter`
+          : key === `clone`
+            ? `chainable getter`
+            : key in String.prototype 
+              ? `method, String override` 
+              : descriptr.value && descriptr.value.constructor === Function
+                ? (isMutating(descriptr.value) 
+                  ? `chainable method${key in customMethods ? ` *custom*` : ``}` : `method`)
+                : descriptr.value
+                  ? `property`
+                  : descriptr.get ? (isMutating(descriptr.get) 
+                    ? `chainable getter${key in customMethods ? ` *custom*` : ``}` 
+                    : `getter`) : `-`})`; })
+    .sort( (a,b) => a.localeCompare(b) ) 
+  );
+}
+
+function createExtendedCTOR(ctor, customMethods) {
+  Object.defineProperties(ctor, {
+    constructor: {
+      get() { return ctor; },
+      enumerable: false,
+    },
+    format: {
+      value(str, ...tokens) {
+        return xString(str).format(...tokens);
+      }
+    },
+    addCustom: {
+      value( { name, method, enumerable = false, isGetter = false } = {} ) {
+        if (xString``[name]) {
+          return console.error(`addCustom: the property "${name}" exists and can not be redefined`);
+        }
+        if (name?.constructor === String && method?.constructor === Function && method.length > 0) {
+          customMethods[name] = {method, enumerable, isGetter};
+        }
+      }
+    },
+    info: {
+      get() { return getSWInformation(); }
+    },
+    keys: {
+      get() { 
+        return Object.keys(Object.getOwnPropertyDescriptors(xString``)).sort( (a,b) => a.localeCompare(b) )
+          .map(v => !/constructor|toString|valueOf/.test(v) && v in customMethods ? `${v} *custom*` : v); 
+      }
+    },
+    quoteInfo: {
+      get() {
+        const qStyles = {...defineQuotingStyles()};
+        delete qStyles.re;
+        return Object.entries(qStyles)
+          .sort( (a,b) => a[0].localeCompare(b[0]) )
+          .reduce((acc, [k, v]) => {
+            const val = v.constructor === Function ? `(start:string[, end:string])` : ` (${v.join(` [instance value] `)})`;
+            return [...acc, `[instance].quote.${k}${val}`];
+          }, []);
+      }
+    },
+    uuid4: {
+      get() { return uuid4(); }
+    },
+    randomString: {
+      value: function({len, includeUppercase, includeNumbers, includeSymbols, startAlphabetic} = {}) {
+        return xString(randomString({len, includeUppercase, includeNumbers, includeSymbols, startAlphabetic})); 
+      }
+    },
+    regExp: { value: createRegExp }
+  });
+  
+  return ctor;
+}
+
+function escapeRE(reString, modifiers) {
+  return new RegExp(reString.replace(/\p{S}|\p{P}/gu, a => `\\${a}`), modifiers);
+}
+
+function decode() {
+  return atob`Rm9yIHRoZSByZWNvcmQ6CltjbV0gY2hhaW5hYmxlIGdldHRlcnMvbWV0aG9kcyBtb2RpZnkgdGhlIGluc3RhbmNlIHN0cmluZwpbY21dIGluZGV4T2Ygb3ZlcnJpZGVzIHJldHVybiBbdW5kZWZpbmVkXSBpZiBub3RoaW5nIHdhcyBmb3VuZCAoc28gb25lIGNhbiB1c2UgW2xhc3RJXWluZGV4T2YoW3NvbWUgc3RyaW5nIHZhbHVlXSkgPz8gMApbY21dIGluY2x1ZGVzIGluZm9ybWF0aW9uIGZvciBjdXN0b20gbWV0aG9kcy9nZXR0ZXJzIGlmIGFwcGxpY2FibGU=`.replace(/\[cm\]/g, `\u2714`);
+}
+
+function defineQuotingStyles() {
+  // see https://en.wikipedia.org/wiki/Quotation_mark
+  const custom = (start, end) => {
+    start = getStringValue(start);
+    end = getStringValue(end);
+    return [getStringValue(start), end.length ? end  : start]; 
+  } 
+  const quots = {
+    backtick: ["`", "`"],
+    bracket: [`{`, `}`],
+    curlyDoubleInward: [`”`, `“`],
+    curlyDouble: [`“`, `”`],
+    curlyDoubleEqual: [`“`, `“`],
+    curlyLHDouble: [`„`, `”`],
+    curlyLHDoubleInward: [`„`, `“`],
+    curlyLHSingle: [`‚`, `’`],
+    curlyLHSingleInward: [`‚`, `‘`],
+    curlySingle: [`‛`, `’`],
+    curlySingleEqual: [`‛`, `‛`],
+    curlySingleInward: [`’`, `‛`],
+    custom,
+    double: [`"`, `"`],
+    guillemets: [`«`, `»`],
+    guillemetsInward: [`»`, `«`],
+    guillemetsSingle: [`‹`, `›`],
+    guillemetsSingleInward: [`›`, `‹`],
+    single: [`'`, `'`],
+    squareBrackets: [`[`, `]`],
+  };
+  const regExpValues = Object.values(quots).filter(v => Array.isArray(v)).map(v => v.map(v => `\\${v}`).join(``)).join('');
+  quots.re = RegExp(`^[${regExpValues}]|[${regExpValues}]$`, "g");
+  return quots;
+}

package/src/instanceMethods.js

@@ -0,0 +1,197 @@
+import interpolate from "./Factories/interpolateFactory.js";
+
+import {isArrayOf, isNumber, defineQuotingStyles, getStringValue, escapeRE} from "./genericMethods.js";
+const quotingStyles = defineQuotingStyles();
+
+export {
+  format, ucFirst, truncate, trimAll, replaceWords,
+  indexOf, lastIndexOf, insert, append,
+  isNumber, prefix, getStringValue, toCamelcase,
+  wordsFirstUp, toDashedNotation, quotGetters,
+  surroundWith, defineQuotingStyles, toSnakeCase,
+};
+
+function checkAndRun(string, fn, or) {
+  string = getStringValue(string);
+  return string.length > 0 ? fn(string) : or || string;
+}
+
+function format(string, ...tokens) {
+  return checkAndRun(string, () => `${interpolate(string, ...tokens)}`); 
+}
+
+function ucFirst(string) {
+  return checkAndRun(string, () => `${string[0].toUpperCase()}${string.slice(1)}`); 
+}
+
+function surroundWith(string, start, end) {
+  if (!start && !end) {
+    return string;
+  }
+  [start, end] = isArrayOf(String, [start, end ?? ``]) ? [start, end] : [``, ``];
+  return `${start}${string}${end || start}`;
+}
+
+function toDashedNotation(string) {
+  return checkAndRun(string, () => 
+    string
+      .replace(/\s/g, '')
+      .replace(/[A-Z]/g, a => `-${a.toLowerCase()}`)
+      .replace(/-{2,}/g, `-`)
+      .replace(/[^a-z-]/g, ``)
+      .replace(/^-|-$/, ``)
+  );
+}
+
+function toSnakeCase(string) {
+  return checkAndRun(string, () =>
+    string
+      .replace(/\s/g, '')
+      .replace(/[A-Z]/g, a => `_${a.toLowerCase()}`)
+      .replace(/_{2,}/g, `_`)
+      .replace(/[^a-z_]/g, ``)
+      .replace(/^_|_$/, ``)
+  );
+}
+
+function wordsFirstUp(string) {
+  return checkAndRun(string, () => [...string.toLowerCase()].slice(1).reduce( (acc, v) =>
+      acc + ( !/\p{L}|[-']/u.test(acc.at(-1)) ? v.toUpperCase() : v.toLowerCase() ),
+    string[0].toUpperCase()
+  ));
+}
+
+function toCamelcase(string) {
+  return checkAndRun(string, () => 
+    string.toLowerCase()
+      .trim()
+      .split(/[- ]/)
+      .filter(l => l && l.length > 0)
+      .map( (str, i) => i > 0 && `${ucFirst(str)}`|| str)
+      .join(``)
+  );
+}
+
+function truncate(string, {at, html = false, wordBoundary = false} = {} ) {
+  return checkAndRun(string, () => {
+    if (string.length <= at) { return string; }
+    
+    const subString = string.slice(0, at - 1);
+    const endwith = html ? "&hellip;" : `...`;
+    const boundary = wordBoundary 
+      ? [...subString.matchAll(/\p{Pe}|\p{Z}/gu)].at(-1)?.index ?? subString.length 
+      : subString.length;
+    
+    return (wordBoundary
+      ? subString.slice(0, boundary+1).trim()
+      : subString) + endwith; 
+    }
+  );
+}
+
+function trimAll(string,  keepLines) {
+  return checkAndRun(string, () => {
+    const lines = string
+      .split(/\n/)
+      .map(line => line.trim().replace(/\s{2,}/g, ` `));
+    return keepLines ? lines.join('\n') : lines.filter(l => l.length > 0).join(`\n`);
+  });
+}
+
+function replaceWords(string, { replacements = {}, caseSensitive = false} = {}) {
+  string = getStringValue(string);
+  let replacements2Array = Object.entries(replacements).flat();
+  const cando = isArrayOf(String, replacements2Array) && caseSensitive?.constructor === Boolean;
+  const modifiers = `g${!caseSensitive ? 'i' : ''}`;
+  
+  if (cando) {
+    replacements2Array = replacements2Array.map(v => getStringValue(v)).filter(v => replacements2Array.length > 0);
+    
+    if (replacements2Array.length) {
+      while (replacements2Array.length) {
+        const [initial, replacement] = [replacements2Array.shift(), replacements2Array.shift()];
+        const re = escapeRE(initial, modifiers);
+        string = string.replace(re, replacement);
+      }
+    }
+  }
+  
+  return string;
+}
+
+// SEE https://youtu.be/99Zacm7SsWQ?t=2101
+function indexOf(string, findMe, fromIndex) {
+  string = getStringValue(string);
+  fromIndex = isNumber(fromIndex) ? fromIndex : 0;
+  const index = string.indexOf(findMe, fromIndex || 0);
+  return index < 0 ? undefined : index;  
+}
+
+function lastIndexOf(string, findMe, beforeIndex) {
+  string = getStringValue(string);
+  beforeIndex = isNumber(beforeIndex) ? beforeIndex : string.length;
+  const index = string.lastIndexOf(findMe, beforeIndex);
+  return index < 0 ? undefined : index;
+}
+
+function insert(string, { value, values, at = 0 } = {}) {
+  string = getStringValue(string);
+  at = isNumber(at) ? at : 0;
+  const valuesMaybeValue = getStringValue(values);
+  values = getStringValue(value).length 
+    ? value
+    : valuesMaybeValue.length
+    ? valuesMaybeValue
+    : isArrayOf(String, values) 
+      ? values.map(v => getStringValue(v)).join(``) 
+      : [];
+  
+  return values.length <= 1
+    ? string
+    : string.length === 0 
+      ? `${values}${string}` 
+      : `${string.slice(0, at)}${values}${string.slice(at)}`;
+}
+
+function prefix(string, ...strings) {
+  strings = isArrayOf(String, strings) && strings;
+  return strings ? insert(getStringValue(string), {values: strings, at: 0}) : getStringValue(string);
+}
+
+function append(string, ...strings2Append) {
+  strings2Append = isArrayOf(String, strings2Append) && strings2Append;
+  
+  if (strings2Append && strings2Append.length > 0) {
+    return `${getStringValue(string)}`.concat(strings2Append.join(``))
+  }
+  
+  return getStringValue(string);
+}
+
+function quotGetters(instance, wrap) {
+  return { 
+    value: {
+      get backtick() { return instance.enclose(...quotingStyles.backtick); },
+      get bracket() { return instance.enclose(...quotingStyles.bracket); },
+      get curlyDouble() { return instance.enclose(...quotingStyles.curlyDouble); },
+      get curlyDoubleInward() { return instance.enclose(...quotingStyles.curlyDoubleInward); },
+      get curlyDoubleEqual() { return instance.enclose(...quotingStyles.curlyDoubleEqual); },
+      get curlyLHDoubleInward() { return instance.enclose(...quotingStyles.curlyLHDoubleInward); },
+      get curlyLHSingle() { return instance.enclose(...quotingStyles.curlyLHSingle); },
+      get curlyLHSingleInward() { return instance.enclose(...quotingStyles.curlyLHSingleInward); },
+      get curlySingle() { return instance.enclose(...quotingStyles.curlySingle); },
+      get curlySingleEqual() { return instance.enclose(...quotingStyles.curlySingleEqual); },
+      get curlySingleInward() { return instance.enclose(...quotingStyles.curlySingleInward); },
+      custom(start, end) { return instance.enclose(...[start, end ?? start]); },
+      get double() { return instance.enclose(...quotingStyles.double);  },
+      get guillemets() { return instance.enclose(...quotingStyles.guillemets); },
+      get guillemetsInward() { return instance.enclose(...quotingStyles.guillemetsInward); },
+      get guillemetsSingle() { return instance.enclose(...quotingStyles.guillemetsSingle); },
+      get guillemetsSingleInward() { return instance.enclose(...quotingStyles.guillemetsSingleInward); },
+      get remove() { return wrap(`${instance.value.replace(quotingStyles.re, ``)}`); },
+      get single() { return instance.enclose(...quotingStyles.single); },
+      get squareBrackets() { return instance.enclose(...quotingStyles.squareBrackets); },
+    }, 
+    enumerable: false 
+  };
+}