inferred-types 0.51.0 → 0.51.2

package/dist/runtime/literals/pluralize.js

@@ -0,0 +1,59 @@
+import { ALPHA_CHARS, PLURAL_EXCEPTIONS, SINGULAR_NOUN_ENDINGS } from "inferred-types/dist/constants/index";
+import { stripTrailing, split, rightWhitespace } from "src/runtime/index";
+const isException = (word) => Object.keys(PLURAL_EXCEPTIONS).includes(word);
+const _END_IN = [
+    "is",
+    "y",
+    "f",
+    "singular-noun"
+];
+/**
+ * pluralize based on how word ends
+ */
+const endingIn = (word, postfix) => {
+    switch (postfix) {
+        case "is":
+            return word.endsWith(postfix) ? `${word}es` : undefined;
+        case "singular-noun":
+            return SINGULAR_NOUN_ENDINGS.some(i => word.endsWith(i))
+                ? split(word).every((i) => [...ALPHA_CHARS].includes(i))
+                    ? `${word}es`
+                    : undefined
+                : undefined;
+        case "f":
+            return word.endsWith("f")
+                ? stripTrailing(word, "f") + "ves"
+                : word.endsWith("fe")
+                    ? stripTrailing(word, "fe") + "ves"
+                    : undefined;
+        case "y":
+            return word.endsWith("y")
+                // ? CONSONANTS.includes(word.slice(-2, 1) as any)
+                ? stripTrailing(word, "y") + "ies"
+                // : undefined
+                : undefined;
+        default:
+            throw new Error(`endingIn received "${postfix}" as a postfix but this ending is not known!`);
+    }
+};
+/**
+ * **pluralize(** word **)**
+ *
+ * Pluralizes the word using _language rules_ on pluralization for English as well as
+ * leveraging many known exceptions to the linguistic rules.
+ *
+ * **Note:** _if the string passed into this function is a literal string then the **type**
+ * will be pluralized along with the runtime value._
+ */
+export const pluralize = (word) => {
+    const right = rightWhitespace(word);
+    const w = word.trimEnd();
+    const result = isException(w)
+        ? PLURAL_EXCEPTIONS[w]
+        : endingIn(w, "is") ||
+            endingIn(w, "singular-noun") ||
+            endingIn(w, "f") ||
+            endingIn(w, "y") ||
+            `${w}s`; // add "s" if no other patterns match
+    return `${result}${right}`;
+};

package/dist/runtime/literals/retainAfter.d.ts

@@ -0,0 +1,32 @@
+import { RetainAfter } from "inferred-types/dist/types/index";
+/**
+ * **retainAfter**`(content, ...find)`
+ *
+ * Runtime utility which removes all characters in a given string _until_
+ * it finds the first instance of a substring defined in **find** variable.
+ *
+ * ### Example
+ * ```ts
+ * // "world"
+ * const world = retainAfter("hello world", " ");
+ * ```
+ *
+ * **Related:** `retainAfterInclusive()`
+ */
+export declare function retainAfter<TContent extends string, TFind extends readonly string[]>(content: TContent, ...find: TFind): RetainAfter<TContent, TFind[number]>;
+/**
+ * **retainAfterInclusive**`(content, ...find)`
+ *
+ * Runtime utility which removes all characters in a given string _until_
+ * it finds the first instance of a substring defined in **find** variable.
+ *
+ * ### Example
+ * ```ts
+ * // " world"
+ * const world = retainAfter("hello world", " ");
+ * ```
+ *
+ * **Related:** `retainAfter()`
+ */
+export declare function retainAfterInclusive<TContent extends string, TFind extends readonly string[]>(content: TContent, ...find: TFind): RetainAfter<TContent, TFind[number], true>;
+//# sourceMappingURL=retainAfter.d.ts.map

package/dist/runtime/literals/retainAfter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retainAfter.d.ts","sourceRoot":"","sources":["../../../src/runtime/literals/retainAfter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAE9D;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CACzB,QAAQ,SAAS,MAAM,EACvB,KAAK,SAAS,SAAS,MAAM,EAAE,EAC/B,OAAO,EAAE,QAAQ,EAAE,GAAG,IAAI,EAAE,KAAK,GAiB5B,WAAW,CAAC,QAAQ,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,CAC1C;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,oBAAoB,CACpC,QAAQ,SAAS,MAAM,EACvB,KAAK,SAAS,SAAS,MAAM,EAAE,EAE7B,OAAO,EAAE,QAAQ,EACjB,GAAG,IAAI,EAAE,KAAK,GAWX,WAAW,CAAC,QAAQ,EAAE,KAAK,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,CAC9C"}

package/dist/runtime/literals/retainAfter.js

@@ -0,0 +1,47 @@
+/**
+ * **retainAfter**`(content, ...find)`
+ *
+ * Runtime utility which removes all characters in a given string _until_
+ * it finds the first instance of a substring defined in **find** variable.
+ *
+ * ### Example
+ * ```ts
+ * // "world"
+ * const world = retainAfter("hello world", " ");
+ * ```
+ *
+ * **Related:** `retainAfterInclusive()`
+ */
+export function retainAfter(content, ...find) {
+    const idx = Math.min(...find.map(i => content.indexOf(i)).filter(i => i > -1));
+    const min = Math.min(...find.map(i => i.length));
+    let len = Math.max(...find.map(i => i.length));
+    if (min !== len) {
+        if (!find.includes(content.slice(idx, len))) {
+            len = min;
+        }
+    }
+    return (idx && idx > 0
+        ? content.slice(idx + len)
+        : "");
+}
+/**
+ * **retainAfterInclusive**`(content, ...find)`
+ *
+ * Runtime utility which removes all characters in a given string _until_
+ * it finds the first instance of a substring defined in **find** variable.
+ *
+ * ### Example
+ * ```ts
+ * // " world"
+ * const world = retainAfter("hello world", " ");
+ * ```
+ *
+ * **Related:** `retainAfter()`
+ */
+export function retainAfterInclusive(content, ...find) {
+    const minFound = Math.min(...find.map(i => content.indexOf(i)).filter(i => i > -1));
+    return (minFound > 0
+        ? content.slice(minFound)
+        : "");
+}

package/dist/runtime/literals/retainChars.d.ts

@@ -0,0 +1,16 @@
+import { RetainChars, TupleToUnion } from "inferred-types/dist/types/index";
+/**
+ * **retainChars**`(content, ...retain)`
+ *
+ * Retains the characters from `retain[]` which are
+ * found in `content` while discarding the rest.
+ *
+ * ```ts
+ * // "42"
+ * const num = retainChars("4foobar2", ...NUMERIC_CHAR);
+ * ```
+ *
+ * **Related:** `stripChars()`, `retainWhile()`, `retainUntil()`
+ */
+export declare const retainChars: <TContent extends string, TRetain extends readonly string[]>(content: TContent, ...retain: TRetain) => RetainChars<TContent, TupleToUnion<TRetain>>;
+//# sourceMappingURL=retainChars.d.ts.map

package/dist/runtime/literals/retainChars.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retainChars.d.ts","sourceRoot":"","sources":["../../../src/runtime/literals/retainChars.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAG5E;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,WAAW,GACtB,QAAQ,SAAS,MAAM,EACvB,OAAO,SAAS,SAAS,MAAM,EAAE,WAExB,QAAQ,aACN,OAAO,KACjB,WAAW,CAAC,QAAQ,EAAE,YAAY,CAAC,OAAO,CAAC,CAK7C,CAAA"}

package/dist/runtime/literals/retainChars.js

@@ -0,0 +1,18 @@
+import { asChars } from "../type-conversion/asChars";
+/**
+ * **retainChars**`(content, ...retain)`
+ *
+ * Retains the characters from `retain[]` which are
+ * found in `content` while discarding the rest.
+ *
+ * ```ts
+ * // "42"
+ * const num = retainChars("4foobar2", ...NUMERIC_CHAR);
+ * ```
+ *
+ * **Related:** `stripChars()`, `retainWhile()`, `retainUntil()`
+ */
+export const retainChars = (content, ...retain) => {
+    let chars = asChars(content);
+    return chars.filter(c => retain.includes(c)).join("");
+};

package/dist/runtime/literals/retainUntil.d.ts

@@ -0,0 +1,32 @@
+import { RetainUntil } from "inferred-types/dist/types/index";
+/**
+ * **retainUntil**`(content, ...find)`
+ *
+ * Runtime utility which retains all characters in a given string _until_
+ * it finds the first instance of a substring defined in **find** variable.
+ *
+ * ### Example
+ * ```ts
+ * // "hello"
+ * const world = retainUntil("hello world", " ");
+ * ```
+ *
+ * **Related:** `retainUntilInclusive()`
+ */
+export declare function retainUntil<TContent extends string, TFind extends readonly string[]>(content: TContent, ...find: TFind): RetainUntil<TContent, TFind[number]>;
+/**
+ * **retainUntil**`(content, ...find)`
+ *
+ * Runtime utility which retains all characters in a given string _until_
+ * it finds the first instance of a substring defined in **find** variable.
+ *
+ * ### Example
+ * ```ts
+ * // "hello "
+ * const world = retainUntilInclusive("hello world", " ");
+ * ```
+ *
+ * **Related:** `retainUntil()`
+ */
+export declare function retainUntilInclusive<TContent extends string, TFind extends readonly string[]>(content: TContent, ...find: TFind): RetainUntil<TContent, TFind[number], true>;
+//# sourceMappingURL=retainUntil.d.ts.map

package/dist/runtime/literals/retainUntil.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retainUntil.d.ts","sourceRoot":"","sources":["../../../src/runtime/literals/retainUntil.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAG9D;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CACzB,QAAQ,SAAS,MAAM,EACvB,KAAK,SAAS,SAAS,MAAM,EAAE,EAC/B,OAAO,EAAE,QAAQ,EAAE,GAAG,IAAI,EAAE,KAAK,GAYjB,WAAW,CAAC,QAAQ,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,CACrD;AAGD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,SAAS,MAAM,EACvB,KAAK,SAAS,SAAS,MAAM,EAAE,EAC/B,OAAO,EAAE,QAAQ,EAAE,GAAG,IAAI,EAAE,KAAK,GAYjB,WAAW,CAAC,QAAQ,EAAE,KAAK,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,CAC3D"}

package/dist/runtime/literals/retainUntil.js

@@ -0,0 +1,49 @@
+import { asChars } from "../type-conversion";
+/**
+ * **retainUntil**`(content, ...find)`
+ *
+ * Runtime utility which retains all characters in a given string _until_
+ * it finds the first instance of a substring defined in **find** variable.
+ *
+ * ### Example
+ * ```ts
+ * // "hello"
+ * const world = retainUntil("hello world", " ");
+ * ```
+ *
+ * **Related:** `retainUntilInclusive()`
+ */
+export function retainUntil(content, ...find) {
+    const chars = asChars(content);
+    let idx = 0;
+    while (!find.includes(chars[idx]) && idx <= chars.length) {
+        idx = idx + 1;
+    }
+    return (idx === 0
+        ? ""
+        : content.slice(0, idx));
+}
+/**
+ * **retainUntil**`(content, ...find)`
+ *
+ * Runtime utility which retains all characters in a given string _until_
+ * it finds the first instance of a substring defined in **find** variable.
+ *
+ * ### Example
+ * ```ts
+ * // "hello "
+ * const world = retainUntilInclusive("hello world", " ");
+ * ```
+ *
+ * **Related:** `retainUntil()`
+ */
+export function retainUntilInclusive(content, ...find) {
+    const chars = asChars(content);
+    let idx = 0;
+    while (!find.includes(chars[idx]) && idx <= chars.length) {
+        idx = idx + 1;
+    }
+    return (idx === 0
+        ? content.slice(0, 1)
+        : content.slice(0, idx + 1));
+}

package/dist/runtime/literals/retainWhile.d.ts

@@ -0,0 +1,10 @@
+import { RetainWhile, TupleToUnion } from "inferred-types/dist/types/index";
+/**
+ * **retainWhile**`(content, ...retain)`
+ *
+ * Retains the characters at the start of the string
+ * so long as they are part of the character values
+ * passed in for `retain[]`
+ */
+export declare const retainWhile: <TContent extends string, TRetain extends readonly string[]>(content: TContent, ...retain: TRetain) => RetainWhile<TContent, TupleToUnion<TRetain>>;
+//# sourceMappingURL=retainWhile.d.ts.map

package/dist/runtime/literals/retainWhile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retainWhile.d.ts","sourceRoot":"","sources":["../../../src/runtime/literals/retainWhile.ts"],"names":[],"mappings":"AAAA,OAAO,EAAG,WAAW,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAI7E;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,GACtB,QAAQ,SAAS,MAAM,EACvB,OAAO,SAAS,SAAS,MAAM,EAAE,WAExB,QAAQ,aACN,OAAO,KAK4B,WAAW,CAAC,QAAQ,EAAE,YAAY,CAAC,OAAO,CAAC,CAC1F,CAAA"}

package/dist/runtime/literals/retainWhile.js

@@ -0,0 +1,13 @@
+import { asChars } from "../type-conversion";
+/**
+ * **retainWhile**`(content, ...retain)`
+ *
+ * Retains the characters at the start of the string
+ * so long as they are part of the character values
+ * passed in for `retain[]`
+ */
+export const retainWhile = (content, ...retain) => {
+    const stopIdx = asChars(content)
+        .findIndex(c => !retain.includes(c));
+    return content.slice(0, stopIdx);
+};

package/dist/runtime/literals/rightWhitespace.d.ts

@@ -0,0 +1,9 @@
+import { TrimLeft } from "inferred-types/dist/types/index";
+import { RetainAfter, Whitespace } from "inferred-types/dist/types/index";
+/**
+ * **rightWhitespace**`(content)`
+ *
+ * Extracts and returns the whitespace on the _right_ part of the string.
+ */
+export declare const rightWhitespace: <T extends string>(content: T) => RetainAfter<TrimLeft<T>, Whitespace, true>;
+//# sourceMappingURL=rightWhitespace.d.ts.map

package/dist/runtime/literals/rightWhitespace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rightWhitespace.d.ts","sourceRoot":"","sources":["../../../src/runtime/literals/rightWhitespace.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAAE,MAAK,iCAAiC,CAAA;AACzD,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AAEzE;;;;GAIG;AACH,eAAO,MAAM,eAAe,GAAI,CAAC,SAAS,MAAM,WAAW,CAAC,KAK1C,WAAW,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,IAAI,CAC1D,CAAA"}

package/dist/runtime/literals/rightWhitespace.js

@@ -0,0 +1,11 @@
+import { WHITESPACE_CHARS } from "inferred-types/dist/constants/index";
+import { retainAfterInclusive } from "./retainAfter";
+/**
+ * **rightWhitespace**`(content)`
+ *
+ * Extracts and returns the whitespace on the _right_ part of the string.
+ */
+export const rightWhitespace = (content) => {
+    const trimmed = content.trimStart();
+    return retainAfterInclusive(trimmed, ...WHITESPACE_CHARS);
+};

package/dist/runtime/literals/split.d.ts

@@ -0,0 +1,13 @@
+import { Chars, IsEqual } from "inferred-types/dist/types/index";
+/**
+ * **split**(str, sep)
+ *
+ * Splits a string on a given separator while preserving string literal typing
+ * where available. Behavior with non-string types is:
+ *
+ * - `number` - converted to string and then split
+ *
+ * All are other types are disallowed.
+ */
+export declare function split<T extends string, S extends string>(str: T, sep?: S): IsEqual<S, ""> extends true ? Chars<T> : readonly string[];
+//# sourceMappingURL=split.d.ts.map

package/dist/runtime/literals/split.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"split.d.ts","sourceRoot":"","sources":["../../../src/runtime/literals/split.ts"],"names":[],"mappings":"AAAA,OAAO,EAAG,KAAK,EAAE,OAAO,EAAE,MAAM,iCAAiC,CAAC;AAElE;;;;;;;;;GASG;AACH,wBAAgB,KAAK,CACnB,CAAC,SAAS,MAAM,EAChB,CAAC,SAAS,MAAM,EAChB,GAAG,EAAE,CAAC,EAAE,GAAG,GAAE,CAAW,GACY,OAAO,CAAC,CAAC,EAAC,EAAE,CAAC,SAAS,IAAI,GAAI,KAAK,CAAC,CAAC,CAAC,GAAG,SAAS,MAAM,EAAE,CAC/F"}

package/dist/runtime/literals/split.js

@@ -0,0 +1,13 @@
+/**
+ * **split**(str, sep)
+ *
+ * Splits a string on a given separator while preserving string literal typing
+ * where available. Behavior with non-string types is:
+ *
+ * - `number` - converted to string and then split
+ *
+ * All are other types are disallowed.
+ */
+export function split(str, sep = "") {
+    return str.split(sep);
+}

package/dist/runtime/literals/stripAfter.d.ts

@@ -0,0 +1,15 @@
+import { StripAfter } from "inferred-types/dist/types/index";
+/**
+ * **stripAfter**(content, find)
+ *
+ * Runtime utility which strips out all characters after (and including)
+ * the "find" string while returning a strong type.
+ *
+ * ### Example
+ * ```ts
+ * // "hello"
+ * const hello = stripAfter("hello world", " ");
+ * ```
+ */
+export declare function stripAfter<TContent extends string, TBreak extends string>(content: TContent, find: TBreak): StripAfter<TContent, TBreak>;
+//# sourceMappingURL=stripAfter.d.ts.map

package/dist/runtime/literals/stripAfter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stripAfter.d.ts","sourceRoot":"","sources":["../../../src/runtime/literals/stripAfter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAE7D;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CACxB,QAAQ,SAAS,MAAM,EACvB,MAAM,SAAS,MAAM,EACrB,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,GACkB,UAAU,CAAC,QAAQ,EAAE,MAAM,CAAC,CAC9E"}

package/dist/runtime/literals/stripAfter.js

@@ -0,0 +1,15 @@
+/**
+ * **stripAfter**(content, find)
+ *
+ * Runtime utility which strips out all characters after (and including)
+ * the "find" string while returning a strong type.
+ *
+ * ### Example
+ * ```ts
+ * // "hello"
+ * const hello = stripAfter("hello world", " ");
+ * ```
+ */
+export function stripAfter(content, find) {
+    return content.split(find).shift();
+}

package/dist/runtime/literals/stripBefore.d.ts

@@ -0,0 +1,15 @@
+import { StripBefore } from "inferred-types/dist/types/index";
+/**
+ * **stripBefore**(content, find)
+ *
+ * Runtime utility which strips out all characters Before (and including)
+ * the "find" string while returning a strong type.
+ *
+ * ### Example
+ * ```ts
+ * // "hello"
+ * const hello = stripBefore("hello world", " ");
+ * ```
+ */
+export declare function stripBefore<TContent extends string, TBreak extends string>(content: TContent, find: TBreak): StripBefore<TContent, TBreak>;
+//# sourceMappingURL=stripBefore.d.ts.map

package/dist/runtime/literals/stripBefore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stripBefore.d.ts","sourceRoot":"","sources":["../../../src/runtime/literals/stripBefore.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAE9D;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CACzB,QAAQ,SAAS,MAAM,EACvB,MAAM,SAAS,MAAM,EACrB,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,GAIb,WAAW,CAAC,QAAQ,EAAE,MAAM,CAAC,CAChD"}

package/dist/runtime/literals/stripBefore.js

@@ -0,0 +1,18 @@
+/**
+ * **stripBefore**(content, find)
+ *
+ * Runtime utility which strips out all characters Before (and including)
+ * the "find" string while returning a strong type.
+ *
+ * ### Example
+ * ```ts
+ * // "hello"
+ * const hello = stripBefore("hello world", " ");
+ * ```
+ */
+export function stripBefore(content, find) {
+    return content
+        .split(find)
+        .slice(1)
+        .join(find);
+}

package/dist/runtime/literals/stripChars.d.ts

@@ -0,0 +1,10 @@
+import { StripChars, TupleToUnion } from "inferred-types/dist/types/index";
+/**
+ * **stripChars**`(content, ...strip)`
+ *
+ * Strips out characters found in `content`.
+ *
+ * **Related:** `retainChars()`
+ */
+export declare const stripChars: <TContent extends string, TRetain extends readonly string[]>(content: TContent, ...strip: TRetain) => StripChars<TContent, TupleToUnion<TRetain>>;
+//# sourceMappingURL=stripChars.d.ts.map

package/dist/runtime/literals/stripChars.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stripChars.d.ts","sourceRoot":"","sources":["../../../src/runtime/literals/stripChars.ts"],"names":[],"mappings":"AAAA,OAAO,EAAG,UAAU,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAG5E;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,GACrB,QAAQ,SAAS,MAAM,EACvB,OAAO,SAAS,SAAS,MAAM,EAAE,WAExB,QAAQ,YACP,OAAO,KAChB,UAAU,CAAC,QAAQ,EAAE,YAAY,CAAC,OAAO,CAAC,CAM5C,CAAA"}

package/dist/runtime/literals/stripChars.js

@@ -0,0 +1,12 @@
+import { asChars } from "src/runtime/index";
+/**
+ * **stripChars**`(content, ...strip)`
+ *
+ * Strips out characters found in `content`.
+ *
+ * **Related:** `retainChars()`
+ */
+export const stripChars = (content, ...strip) => {
+    let chars = asChars(content);
+    return (chars.filter(c => !strip.includes(c)).join(""));
+};

package/dist/runtime/literals/stripLeading.d.ts

@@ -0,0 +1,9 @@
+import { StripLeading, TupleToUnion } from "inferred-types/dist/types/index";
+/**
+ * **stripLeading**(content, ...strip)
+ *
+ * Runtime utility which strips of a leading substring from the
+ * primary content if it exists and leaves content unchanged otherwise.
+ */
+export declare function stripLeading<T extends string | number, U extends readonly (string | number)[]>(content: T, ...strip: U): StripLeading<T, TupleToUnion<U>>;
+//# sourceMappingURL=stripLeading.d.ts.map

package/dist/runtime/literals/stripLeading.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stripLeading.d.ts","sourceRoot":"","sources":["../../../src/runtime/literals/stripLeading.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAG7E;;;;;GAKG;AACH,wBAAgB,YAAY,CAC1B,CAAC,SAAS,MAAM,GAAG,MAAM,EACzB,CAAC,SAAS,SAAS,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,EAEtC,OAAO,EAAE,CAAC,EACV,GAAG,KAAK,EAAE,CAAC,GAYK,YAAY,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC,CACjD"}

package/dist/runtime/literals/stripLeading.js

@@ -0,0 +1,16 @@
+import { isNumber } from "../type-guards/isNumber";
+/**
+ * **stripLeading**(content, ...strip)
+ *
+ * Runtime utility which strips of a leading substring from the
+ * primary content if it exists and leaves content unchanged otherwise.
+ */
+export function stripLeading(content, ...strip) {
+    let output = String(content);
+    for (const s of strip) {
+        if (output.startsWith(String(s))) {
+            output = output.slice(String(s).length);
+        }
+    }
+    return (isNumber(content) ? Number(output) : output);
+}

package/dist/runtime/literals/stripSurround.d.ts

@@ -0,0 +1,19 @@
+import { StripSurround } from "inferred-types/dist/types/index";
+export type StripSurroundConfigured<TStrip extends readonly (string | number)[]> = <TInput extends string | number>(input: TInput) => StripSurround<TInput, TStrip[number]>;
+/**
+ * **stripSurround**`(chars) => (input) => _stripped_`
+ *
+ * A higher order function which allows you to define a string literal
+ * stripping function for both the beginning and end of a string literal.
+ *
+ * ```ts
+ * // utility which will strip all starting and ending brackets
+ * const stripBrackets = stripSurround("(", ")", "[", "]", "{", "}");
+ * // " hello, world "
+ * const without = stripBrackets("[ hello, world ]")
+ * ```
+ *
+ * **Related**: `stripSurroundAndTrim`
+ */
+export declare const stripSurround: <TChars extends readonly (number | string)[]>(...chars: TChars) => StripSurroundConfigured<TChars>;
+//# sourceMappingURL=stripSurround.d.ts.map

package/dist/runtime/literals/stripSurround.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stripSurround.d.ts","sourceRoot":"","sources":["../../../src/runtime/literals/stripSurround.ts"],"names":[],"mappings":"AACA,OAAO,EACL,aAAa,EACd,MAAM,iCAAiC,CAAC;AAGzC,MAAM,MAAM,uBAAuB,CACjC,MAAM,SAAS,SAAS,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,IACzC,CAAC,MAAM,SAAS,MAAM,GAAG,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,aAAa,CAClE,MAAM,EACN,MAAM,CAAC,MAAM,CAAC,CACf,CAAC;AAGF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,aAAa,GACxB,MAAM,SAAS,SAAS,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,YAEjC,MAAM,KACf,uBAAuB,CAAC,MAAM,CAmBhC,CAAA"}

package/dist/runtime/literals/stripSurround.js

@@ -0,0 +1,30 @@
+import { isNumber } from "../type-guards/isNumber";
+/**
+ * **stripSurround**`(chars) => (input) => _stripped_`
+ *
+ * A higher order function which allows you to define a string literal
+ * stripping function for both the beginning and end of a string literal.
+ *
+ * ```ts
+ * // utility which will strip all starting and ending brackets
+ * const stripBrackets = stripSurround("(", ")", "[", "]", "{", "}");
+ * // " hello, world "
+ * const without = stripBrackets("[ hello, world ]")
+ * ```
+ *
+ * **Related**: `stripSurroundAndTrim`
+ */
+export const stripSurround = (...chars) => {
+    return (input) => {
+        let output = String(input);
+        for (const s of chars) {
+            if (output.startsWith(String(s))) {
+                output = output.slice(String(s).length);
+            }
+            if (output.endsWith(String(s))) {
+                output = output.slice(0, -1 * String(s).length);
+            }
+        }
+        return (isNumber(input) ? Number(output) : output);
+    };
+};

package/dist/runtime/literals/stripTrailing.d.ts

@@ -0,0 +1,9 @@
+import { StripTrailing, TupleToUnion } from "inferred-types/dist/types/index";
+/**
+ * **stripTrailing**(content, strip)
+ *
+ * Runtime utility which ensures that last part of a string has substring
+ * removed if it exists and that strong typing is preserved.
+ */
+export declare function stripTrailing<T extends string | number, U extends readonly (string | number)[]>(content: T, ...strip: U): StripTrailing<T, TupleToUnion<U>>;
+//# sourceMappingURL=stripTrailing.d.ts.map

package/dist/runtime/literals/stripTrailing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stripTrailing.d.ts","sourceRoot":"","sources":["../../../src/runtime/literals/stripTrailing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAG9E;;;;;GAKG;AACH,wBAAgB,aAAa,CAC3B,CAAC,SAAS,MAAM,GAAG,MAAM,EACzB,CAAC,SAAS,SAAS,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,EAEtC,OAAO,EAAE,CAAC,EACV,GAAG,KAAK,EAAE,CAAC,GACV,aAAa,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC,CAYnC"}

package/dist/runtime/literals/stripTrailing.js

@@ -0,0 +1,16 @@
+import { isNumber } from "../type-guards/index";
+/**
+ * **stripTrailing**(content, strip)
+ *
+ * Runtime utility which ensures that last part of a string has substring
+ * removed if it exists and that strong typing is preserved.
+ */
+export function stripTrailing(content, ...strip) {
+    let output = String(content);
+    for (const s of strip) {
+        if (output.endsWith(String(s))) {
+            output = output.slice(0, -1 * String(s).length);
+        }
+    }
+    return (isNumber(content) ? Number(output) : output);
+}

package/dist/runtime/literals/stripUntil.d.ts

@@ -0,0 +1,9 @@
+import { TupleToUnion, StripUntil } from "inferred-types/dist/types/index";
+/**
+ * **stripUntil**`(content, ...until)`
+ *
+ * Strips the characters at the start of the string
+ * until a character specified in `until` is found.
+ */
+export declare const stripUntil: <TContent extends string, TUntil extends readonly string[]>(content: TContent, ...until: TUntil) => StripUntil<TContent, TupleToUnion<TUntil>>;
+//# sourceMappingURL=stripUntil.d.ts.map

package/dist/runtime/literals/stripUntil.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stripUntil.d.ts","sourceRoot":"","sources":["../../../src/runtime/literals/stripUntil.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAC,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAE1E;;;;;GAKG;AACH,eAAO,MAAM,UAAU,GACrB,QAAQ,SAAS,MAAM,EACvB,MAAM,SAAS,SAAS,MAAM,EAAE,WACvB,QAAQ,YAAY,MAAM,KAIS,UAAU,CAAC,QAAQ,EAAE,YAAY,CAAC,MAAM,CAAC,CACtF,CAAA"}

package/dist/runtime/literals/stripUntil.js

@@ -0,0 +1,12 @@
+import { asChars } from "../type-conversion/index";
+/**
+ * **stripUntil**`(content, ...until)`
+ *
+ * Strips the characters at the start of the string
+ * until a character specified in `until` is found.
+ */
+export const stripUntil = (content, ...until) => {
+    const stopIdx = asChars(content)
+        .findIndex(c => until.includes(c));
+    return content.slice(stopIdx);
+};

package/dist/runtime/literals/stripWhile.d.ts

@@ -0,0 +1,10 @@
+import { StripWhile } from "inferred-types/dist/types/index";
+/**
+ * **stripWhile**`(content, ...until)`
+ *
+ * Strips the characters at the start of the string
+ * while they match the characters found in `match`
+ * parameter.
+ */
+export declare const stripWhile: <TContent extends string, TMatch extends readonly string[]>(content: TContent, ...match: TMatch) => StripWhile<TContent, TMatch[number]>;
+//# sourceMappingURL=stripWhile.d.ts.map

package/dist/runtime/literals/stripWhile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stripWhile.d.ts","sourceRoot":"","sources":["../../../src/runtime/literals/stripWhile.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAE7D;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,GACrB,QAAQ,SAAS,MAAM,EACvB,MAAM,SAAS,SAAS,MAAM,EAAE,WACvB,QAAQ,YAAY,MAAM,KAIS,UAAU,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,CAAC,CAChF,CAAA"}