littoral-templates 0.4.0-rc.1 → 0.4.0-rc.3

package/CHANGELOG.md

@@ -4,6 +4,12 @@
 
 * Thunks returning a `Template` are now `Template`s as well.
 * The 3rd (Curried) argument of `indentWith`, and the 2nd (Curried) argument of `when` are now variadic.
+* The EOL style can be taken from the OS, using the asynchronous `setEOLStyleFromOS` function.
+  The `asString` returns a string that uses that EOL style *exclusively*.
+  Multi-line strings inside a template are therefore now split on `/\r*\n/` rather than just `/\n/`, so that `asString` effectively normalizes EOL style.
+* The `withNewlineAppended` function has been renamed to `withEmptyLineAppended`.
+  (The former is kept as a legacy alias.)
+* An object constant `commonIndentations` is added and exposed which holds the most common indentation styles: “2 spaces”, “4 spaces”, and “1 tab”.
 
 
 ## 0.3.0
@@ -11,9 +17,8 @@
 * Turn the package into an ESM module (back again).
   (Should work with Deno in the meanwhile.)
 * Update dependencies: no impact on shipped code.
-* Add functions: `when`, `withNewlineAppended`, and `commaSeparated`.
-* Rename `NestedString` to `Template`, leaving `NestedString` as an alias.
-  This is  not a breaking change, but I might deprecate and remove `NestedString` in the future.
+* Add functions: `when`, `withEmptyLineAppended`, and `commaSeparated`.
+* Rename `NestedString` to `Template`, leaving `NestedString` as a legacy alias, which might be deprecated and removed in the future.
 * Add {T|J}SDoc.
 
 

package/README.md

@@ -1,57 +1,73 @@
 # littoral-templates
 
-A small JavaScript/TypeScript framework to do templating comfortably using the [template literal](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals) syntax in either JavaScript or TypeScript.
-It doesn't come with its own syntax, like frameworks like [mustache](https://mustache.github.io/), and [handlebars](https://handlebarsjs.com/) do.
+A small JavaScript/TypeScript framework to do light-weight templating – e.g. for doing code generation – comfortably using the [template literal](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals) syntax in either JavaScript or TypeScript.
 
-Instead, templates look as follows:
 
-```typescript
+## Quickstart
+
+`littoral-templates` doesn’t come with its own syntax, like frameworks like [mustache](https://mustache.github.io/), and [handlebars](https://handlebarsjs.com/) do.
+Instead, templates are written as ordinary JavaScript/TypeScript code.
+They look as follows:
+
+```javascript
 [
     `top-level`,
     [ `still top-level, but on a new line` ],
     indent(1)([
         `this is indented (1 level)`,
-        indent(2)([
+        indent(2)(() => [
             `this is much more indented (3 levels)`
         ])
     ])
 ]
 ```
 
-Instances of the `Template` type are arrays of strings nested to an arbitrary depth/level.
-(Depth 0 corresponds to a single string).
-To convert this to a proper string, use the `asString` function, as follows:
+Templates – i.e.: instances of the `Template` type – are either strings, no-args functions returning a template, or arrays of templates.
+This is a circular definition, so you can have nesting to an arbitrary depth/level.
+
+To convert a template back to a proper string, use the **`asString`** function, as follows:
 
 ```typescript
-import {asString, indentWith} from "littoral-templates"
+import {asString, commonIndentations, indentWith} from "littoral-templates"
 
-const indent = indentWith("    ")
+const indent = indentWith(commonIndentations["2 spaces"])
 
 console.log(
     asString(<the template from the listing above>)
 )
 ```
 
+The `indent` function is a function that takes one argument: the indentation level — let’s call that _n_.
+It then returns a *template function* that takes a template as its argument, and returns a template that is indented to indentation level _n_, using 2 spaces for each indentation.
+Defining the `indent` function uses the `indentWith` function.
+
 This code produces the following text on the JavaScript console:
 
-```
+```javascript
 top-level
 still top-level, but on a new line
-    this is indented (1 level)
-            this is even more indented (3 levels)
+  this is indented (1 level)
+      this is even more indented (3 levels)
 ```
 
+This makes for a convenient way to generate code with correct indentation levels.
+
+Be sure to check out the [cookbook](#cookbook) below to learn how to use `littoral-templates` for common templating tasks conveniently.
+Read the [fundamentals](#fundamentals) below to learn more about the concepts underlying this package.
+
+
+## Cookbook
 
 ### Iterating over collections
 
-A common activity in templates is to iterate over a collection and map each item to text.
+A common activity in code generation is to iterate over a collection and map each item to text.
 These sub-texts would then have to be joined together, and taking care of correct indentation is then usually quite a hassle.
 Using the `Template` type, you can simply use the `Array.map` function, as follows:
 
 ```typescript
 import {asString, indentWith} from "littoral-templates"
 
-const indent = indentWith("    ")
+const indent = indentWith(commonIndentations["2 spaces"])
 
 console.log(
     asString([
@@ -112,7 +128,7 @@ const template = [
 ]
 ```
 
-Using side effects inside a template can be useful to store information that's needed elsewhere in the text-to-generate.
+Using side effects inside a template can be useful to store information that’s needed elsewhere in the text-to-generate.
 An example of that would be to keep track of imports that have to appear before their usage.
 
 
@@ -120,14 +136,14 @@ An example of that would be to keep track of imports that have to appear before
 
 Other convenience functions are:
 
-* `withNewlineAppended`: Wrap this around a template function (see definition below) to produce a template function that adds a newline after any item fed to the original template function.
+* `withEmptyLineAppended`: Wrap this around a template function (see definition below) to produce a template function that adds an empty line after any item fed to the original template function.
 
     A _template function_ is any function that produces an instance of `Template`.
 
-    An example of the usage of `withNewlineAppended` is
+    An example of the usage of `withEmptyLineAppended` is
 
     ```typescript
-    [1, 2, 3].map(withNewlineAppended((num) => `${num}`))
+    [1, 2, 3].map(withEmptyLineAppended((num) => `${num}`))
     ```
 
     which should produce the following text:
@@ -149,9 +165,54 @@ Other convenience functions are:
     _Note_ that this only works on a list of strings, not an any instance of `Template`.
 
 
-### Package name
+### EOLs
+
+EOLs – AKA “newlines” or “line endings” – vary between OS's: Windows uses `crlf` EOL style – `\r\n` –, while essentially all other mainstream OS's use `lf` style – `\n`.
+Not taking that into account can cause content being generated differently across OS's, potentially confusing tools like Git — especially if these are not configured correctly.
+Since generated content is often large, this causes additional confusion and friction in the software development process.
+
+To prevent such issues, you can set the EOL style by calling the `setEOLStyleFromOS` function before any calls to `asString`.
+The default value for the EOL style is `lf` – meaning `\n`.
+I’ll use the notation `<eol>` for the currently-set EOL value throughout the rest of the documentation.
+
+
+## Fundamentals
+
+Templates are in essence *line-oriented*: each single-line string (containing no EOL of any style) inside a template – no matter how deeply nested it occurs – corresponds to one line after calling `asString`.
+In code, all the following expressions result in a value of `"foo<eol>"` when calling `asString` with them:
+
+```javascript
+"foo"
+["foo"]
+[["foo"]]
+() => ["foo"]
+[() => ["foo"]]
+```
+
+A multi-line string inside a template is split on EOL of any style, retaining the exact number of lines that it originally had.
+So:
+
+```javascript
+asString([`foo
+`])
+```
+
+evaluates to `"foo<eol><eol>"`.
+
+Splitting is done on *EOLs of any style*, so this *effectively normalizes* EOLs, meaning that even if multi-line strings use different EOL, `asString` will only use the set EOL style.
+
+Templates **compose** nicely, and predictably, e.g.:
+
+```javascript
+asString([t1, t2]) === `${asString(t1)}${asString(t2)}`
+```
+
+The expression `asString([])` evaluates to the empty string, which both satisfies the property above, and is useful as a “nil” template that doesn't result in a new/empty line in the output.
+
+
+## Package name
 
-The repository's name is a play on "temporal literals" and "littoral", begin phonetically close to "literal".
-The latter word indicates the part of a body of water (lake, sea, or ocean) that's closest to shore, usually shallow, and possibly not always entirely submerged.
-The name tries to convey that implementing templates with this framework doesn't require you to "wade too far into the water".
+The repository’s name is a play on “temporal literals” and “littoral”, begin phonetically close to “literal”.
+The latter word indicates the part of a body of water (lake, sea, or ocean) that’s closest to shore, usually shallow, and possibly not always entirely submerged.
+The name tries to convey that implementing templates with this framework doesn’t require you to “wade too far into the water”.
 

package/dist/eol.d.ts

@@ -0,0 +1,29 @@
+/**
+ * EOL-related constants and functions.
+ */
+/**
+ * Common EOL styles.
+ */
+export declare const eolStyles: {
+    readonly lf: "\n";
+    readonly crlf: "\r\n";
+};
+/**
+ * The value of the EOL string: typically, either "\n" (=LF-style, compatible with POSIX/Linux/macOS), or "\r\n" (=CRLF-style, compatible with Windows).
+ */
+export declare let eol: string;
+/**
+ * Sets the EOL to the OS-dependent value.
+ */
+export declare const setEOLStyleFromOS: () => Promise<void>;
+/**
+ * Sets the EOL explicitly to the given value.
+ * (This is especially useful for testing.)
+ */
+export declare const setEOLExplicitly: (newEol: string) => void;
+/**
+ * Splits the given string on EOLs (of any style) into an array of strings,
+ * each corresponding to one line.
+ */
+export declare const splitOnEOL: (str: string) => string[];
+//# sourceMappingURL=eol.d.ts.map

package/dist/eol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eol.d.ts","sourceRoot":"","sources":["../src/eol.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;GAEG;AACH,eAAO,MAAM,SAAS;;;CAGZ,CAAA;AAGV;;GAEG;AACH,eAAO,IAAI,GAAG,EAAE,MAAqB,CAAA;AAGrC;;GAEG;AACH,eAAO,MAAM,iBAAiB,QAAa,QAAQ,IAAI,CAGjD,CAAA;AAGN;;;GAGG;AACH,eAAO,MAAM,gBAAgB,WAAY,MAAM,SAE9C,CAAA;AAKD;;;GAGG;AACH,eAAO,MAAM,UAAU,QAAS,MAAM,KAAG,MAAM,EACtB,CAAA"}

package/dist/eol.js

@@ -0,0 +1,81 @@
+/**
+ * EOL-related constants and functions.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+/**
+ * Common EOL styles.
+ */
+export var eolStyles = {
+    lf: "\n",
+    crlf: "\r\n"
+};
+/**
+ * The value of the EOL string: typically, either "\n" (=LF-style, compatible with POSIX/Linux/macOS), or "\r\n" (=CRLF-style, compatible with Windows).
+ */
+export var eol = eolStyles.lf;
+/**
+ * Sets the EOL to the OS-dependent value.
+ */
+export var setEOLStyleFromOS = function () { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        return [2 /*return*/, import("os").then(function (os) {
+                eol = os.EOL;
+            })
+            /**
+             * Sets the EOL explicitly to the given value.
+             * (This is especially useful for testing.)
+             */
+        ];
+    });
+}); };
+/**
+ * Sets the EOL explicitly to the given value.
+ * (This is especially useful for testing.)
+ */
+export var setEOLExplicitly = function (newEol) {
+    eol = newEol;
+};
+var splitRegex = new RegExp(/\r*\n/);
+/**
+ * Splits the given string on EOLs (of any style) into an array of strings,
+ * each corresponding to one line.
+ */
+export var splitOnEOL = function (str) {
+    return str.split(splitRegex);
+};
+//# sourceMappingURL=eol.js.map

package/dist/eol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"eol.js","sourceRoot":"","sources":["../src/eol.ts"],"names":[],"mappings":"AAAA;;GAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH;;GAEG;AACH,MAAM,CAAC,IAAM,SAAS,GAAG;IACrB,EAAE,EAAE,IAAI;IACR,IAAI,EAAE,MAAM;CACN,CAAA;AAGV;;GAEG;AACH,MAAM,CAAC,IAAI,GAAG,GAAW,SAAS,CAAC,EAAE,CAAA;AAGrC;;GAEG;AACH,MAAM,CAAC,IAAM,iBAAiB,GAAG;;QAC7B,sBAAA,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,UAAC,EAAE;gBACjB,GAAG,GAAG,EAAE,CAAC,GAAG,CAAA;YAChB,CAAC,CAAC;YAGN;;;eAGG;UANG;;KAAA,CAAA;AAGN;;;GAGG;AACH,MAAM,CAAC,IAAM,gBAAgB,GAAG,UAAC,MAAc;IAC3C,GAAG,GAAG,MAAM,CAAA;AAChB,CAAC,CAAA;AAGD,IAAM,UAAU,GAAG,IAAI,MAAM,CAAC,OAAO,CAAC,CAAA;AAEtC;;;GAGG;AACH,MAAM,CAAC,IAAM,UAAU,GAAG,UAAC,GAAW;IAClC,OAAA,GAAG,CAAC,KAAK,CAAC,UAAU,CAAC;AAArB,CAAqB,CAAA"}

package/dist/functions.d.ts

@@ -1,26 +1,7 @@
-import { Template } from "./types.js";
 /**
- * @returns {string} - the given template joined as one string, taking care of proper newline endings.
+ * Non-primitive functions on the {@link Template} type.
  */
-export declare const asString: (template: Template) => string;
-/**
- * @returns a function to instantiate a function to indent a sub-template.
- * The function always returns an array of strings.
- *
- * Its usage looks as follows:
- * <pre>
- * indentWith("  ")(2)([
- *     `this is indented 2 levels`
- * ])
- * </pre>
- * Note that the third Curried argument is variadic, so the array brackets (`[]`) can be elided.
- *
- * Usually, one sets up the following function constant before:
- * <pre>
- * const indent = indentWith("  ")
- * </pre>
- */
-export declare const indentWith: (singleIndentation: string) => (indentLevel?: number) => (...templates: Template[]) => string[];
+import { Template } from "./index-internal.js";
 /**
  * Allows for the following syntax:
  * <pre>
@@ -49,7 +30,12 @@ export declare const indentWith: (singleIndentation: string) => (indentLevel?: n
  */
 export declare const when: (bool: boolean) => (...whenResults: Template[]) => Template;
 /**
- * @return a function that composes the given template function with the action of "adding a newline after".
+ * @return a function that composes the given template function with the action of "adding an empty line after".
+ */
+export declare const withEmptyLineAppended: <T>(templateFunc: (t: T) => Template) => (t: T) => Template[];
+/**
+ * A legacy alias of {@link withEmptyLineAppended}.
+ * Note: this function might be deprecated and removed (per a major version) in the future.
  */
 export declare const withNewlineAppended: <T>(templateFunc: (t: T) => Template) => (t: T) => Template[];
 //# sourceMappingURL=functions.d.ts.map

package/dist/functions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"functions.d.ts","sourceRoot":"","sources":["../src/functions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,QAAQ,EAAC,MAAM,YAAY,CAAA;AAkBnC;;GAEG;AACH,eAAO,MAAM,QAAQ,aAAc,QAAQ,KAAG,MACQ,CAAA;AAGtD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,UAAU,sBAAuB,MAAM,oBAClC,MAAM,oBAGM,QAAQ,EAAE,aAEnC,CAAA;AAGL;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,IAAI,SAAU,OAAO,sBAAqB,QAAQ,EAAE,KAAK,QAGnD,CAAA;AAGnB;;GAEG;AACH,eAAO,MAAM,mBAAmB,8BAA+B,QAAQ,yBACpC,CAAA"}
+{"version":3,"file":"functions.d.ts","sourceRoot":"","sources":["../src/functions.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAY,QAAQ,EAAC,MAAM,qBAAqB,CAAA;AAEvD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,IAAI,SAAU,OAAO,sBAAqB,QAAQ,EAAE,KAAK,QAGnD,CAAA;AAGnB;;GAEG;AACH,eAAO,MAAM,qBAAqB,8BAA+B,QAAQ,yBACtC,CAAA;AAEnC;;;GAGG;AACH,eAAO,MAAM,mBAAmB,8BAPiC,QAAQ,yBAOjB,CAAA"}

package/dist/functions.js

@@ -1,62 +1,7 @@
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-import { repeat, withNewlineEnsured } from "./string-utils.js";
 /**
- * “Flattens” the given template to an array of strings, each of which represent exactly one line.
- */
-var flatten = function (template) {
-    if (typeof template === "function") {
-        return flatten(template());
-    }
-    if (Array.isArray(template)) {
-        return template.map(flatten).reduce(function (arrL, arrR) { return __spreadArray(__spreadArray([], arrL, true), arrR, true); }, []);
-    }
-    return template.split("\n");
-};
-/**
- * @returns {string} - the given template joined as one string, taking care of proper newline endings.
- */
-export var asString = function (template) {
-    return flatten(template).map(withNewlineEnsured).join("");
-};
-/**
- * @returns a function to instantiate a function to indent a sub-template.
- * The function always returns an array of strings.
- *
- * Its usage looks as follows:
- * <pre>
- * indentWith("  ")(2)([
- *     `this is indented 2 levels`
- * ])
- * </pre>
- * Note that the third Curried argument is variadic, so the array brackets (`[]`) can be elided.
- *
- * Usually, one sets up the following function constant before:
- * <pre>
- * const indent = indentWith("  ")
- * </pre>
+ * Non-primitive functions on the {@link Template} type.
  */
-export var indentWith = function (singleIndentation) {
-    return function (indentLevel) {
-        if (indentLevel === void 0) { indentLevel = 1; }
-        var prefix = repeat(singleIndentation, indentLevel);
-        var indenter = function (line) { return line.length > 0 ? (prefix + line) : line; };
-        return function () {
-            var templates = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                templates[_i] = arguments[_i];
-            }
-            return flatten(templates).map(indenter);
-        }; // Note: Template[] has type Template as well!
-    };
-};
+import { flattened } from "./index-internal.js";
 /**
  * Allows for the following syntax:
  * <pre>
@@ -90,14 +35,19 @@ export var when = function (bool) {
             for (var _i = 0; _i < arguments.length; _i++) {
                 whenResults[_i] = arguments[_i];
             }
-            return flatten(whenResults);
+            return flattened(whenResults);
         } // (need to be explicit here, or it doesn't work – despite having specified the return type...)
         : function (_) { return []; };
 };
 /**
- * @return a function that composes the given template function with the action of "adding a newline after".
+ * @return a function that composes the given template function with the action of "adding an empty line after".
  */
-export var withNewlineAppended = function (templateFunc) {
+export var withEmptyLineAppended = function (templateFunc) {
     return function (t) { return [templateFunc(t), ""]; };
 };
+/**
+ * A legacy alias of {@link withEmptyLineAppended}.
+ * Note: this function might be deprecated and removed (per a major version) in the future.
+ */
+export var withNewlineAppended = withEmptyLineAppended;
 //# sourceMappingURL=functions.js.map

package/dist/functions.js.map

@@ -1 +1 @@
-{"version":3,"file":"functions.js","sourceRoot":"","sources":["../src/functions.ts"],"names":[],"mappings":";;;;;;;;;AACA,OAAO,EAAC,MAAM,EAAE,kBAAkB,EAAC,MAAM,mBAAmB,CAAA;AAG5D;;GAEG;AACH,IAAM,OAAO,GAAG,UAAC,QAAkB;IAC/B,IAAI,OAAO,QAAQ,KAAK,UAAU,EAAE,CAAC;QACjC,OAAO,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAA;IAC9B,CAAC;IACD,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC1B,OAAO,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,UAAC,IAAI,EAAE,IAAI,IAAK,uCAAI,IAAI,SAAK,IAAI,SAAjB,CAAkB,EAAE,EAAE,CAAC,CAAA;IAC/E,CAAC;IACD,OAAO,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;AAC/B,CAAC,CAAA;AAGD;;GAEG;AACH,MAAM,CAAC,IAAM,QAAQ,GAAG,UAAC,QAAkB;IACvC,OAAA,OAAO,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC;AAAlD,CAAkD,CAAA;AAGtD;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,IAAM,UAAU,GAAG,UAAC,iBAAyB;IAChD,OAAA,UAAC,WAAuB;QAAvB,4BAAA,EAAA,eAAuB;QACpB,IAAM,MAAM,GAAG,MAAM,CAAC,iBAAiB,EAAE,WAAW,CAAC,CAAA;QACrD,IAAM,QAAQ,GAAG,UAAC,IAAY,IAAK,OAAA,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,EAAxC,CAAwC,CAAA;QAC3E,OAAO;YAAC,mBAAwB;iBAAxB,UAAwB,EAAxB,qBAAwB,EAAxB,IAAwB;gBAAxB,8BAAwB;;YAC5B,OAAA,OAAO,CAAC,SAAS,CAAC,CAAC,GAAG,CAAC,QAAQ,CAAC;QAAhC,CAAgC,CAAA,CAAI,8CAA8C;IAC1F,CAAC;AALD,CAKC,CAAA;AAGL;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,IAAM,IAAI,GAAG,UAAC,IAAa;IAC9B,OAAA,IAAI;QACA,CAAC,CAAC;YAAC,qBAA0B;iBAA1B,UAA0B,EAA1B,qBAA0B,EAA1B,IAA0B;gBAA1B,gCAA0B;;YAAK,OAAA,OAAO,CAAC,WAAW,CAAC;QAApB,CAAoB,CAAE,+FAA+F;QACvJ,CAAC,CAAC,UAAC,CAAC,IAAK,OAAA,EAAE,EAAF,CAAE;AAFf,CAEe,CAAA;AAGnB;;GAEG;AACH,MAAM,CAAC,IAAM,mBAAmB,GAAG,UAAI,YAAgC;IACnE,OAAA,UAAC,CAAI,IAAK,OAAA,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,EAArB,CAAqB;AAA/B,CAA+B,CAAA"}
+{"version":3,"file":"functions.js","sourceRoot":"","sources":["../src/functions.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAC,SAAS,EAAW,MAAM,qBAAqB,CAAA;AAEvD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,IAAM,IAAI,GAAG,UAAC,IAAa;IAC9B,OAAA,IAAI;QACA,CAAC,CAAC;YAAC,qBAA0B;iBAA1B,UAA0B,EAA1B,qBAA0B,EAA1B,IAA0B;gBAA1B,gCAA0B;;YAAK,OAAA,SAAS,CAAC,WAAW,CAAC;QAAtB,CAAsB,CAAE,+FAA+F;QACzJ,CAAC,CAAC,UAAC,CAAC,IAAK,OAAA,EAAE,EAAF,CAAE;AAFf,CAEe,CAAA;AAGnB;;GAEG;AACH,MAAM,CAAC,IAAM,qBAAqB,GAAG,UAAI,YAAgC;IACrE,OAAA,UAAC,CAAI,IAAK,OAAA,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,EAArB,CAAqB;AAA/B,CAA+B,CAAA;AAEnC;;;GAGG;AACH,MAAM,CAAC,IAAM,mBAAmB,GAAG,qBAAqB,CAAA"}

package/dist/indents.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Indentation-related constants and functions.
+ */
+import { Template } from "./index-internal.js";
+/**
+ * @returns a function to instantiate a function to indent a sub-template.
+ * The function always returns an array of strings.
+ *
+ * Its usage looks as follows:
+ * <pre>
+ * indentWith("  ")(2)([
+ *     `this is indented 2 levels`
+ * ])
+ * </pre>
+ * Note that the third Curried argument is variadic, so the array brackets (`[]`) can be elided.
+ *
+ * Usually, one sets up the following function constant before:
+ * <pre>
+ * const indent = indentWith("  ")
+ * </pre>
+ */
+export declare const indentWith: (singleIndentation: string) => (indentLevel?: number) => (...templates: Template[]) => string[];
+/**
+ * An enumeration of common indentation styles.
+ * Use these in a type-safe way as follows, e.g. for “1 tab”:
+ *
+ * ```
+ * const indent = indentWith(commonIndentations["1 tab"])
+ *
+ * indent([`foo`])
+ * ```
+ */
+export declare const commonIndentations: {
+    readonly "2 spaces": "  ";
+    readonly "4 spaces": "    ";
+    readonly "1 tab": "\t";
+};
+//# sourceMappingURL=indents.d.ts.map

package/dist/indents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"indents.d.ts","sourceRoot":"","sources":["../src/indents.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAoB,QAAQ,EAAC,MAAM,qBAAqB,CAAA;AAE/D;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,UAAU,sBAAuB,MAAM,oBAClC,MAAM,oBAGM,QAAQ,EAAE,aAEnC,CAAA;AAEL;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB;;;;CAIrB,CAAA"}

package/dist/indents.js

@@ -0,0 +1,51 @@
+/**
+ * Indentation-related constants and functions.
+ */
+import { flattened, repeat } from "./index-internal.js";
+/**
+ * @returns a function to instantiate a function to indent a sub-template.
+ * The function always returns an array of strings.
+ *
+ * Its usage looks as follows:
+ * <pre>
+ * indentWith("  ")(2)([
+ *     `this is indented 2 levels`
+ * ])
+ * </pre>
+ * Note that the third Curried argument is variadic, so the array brackets (`[]`) can be elided.
+ *
+ * Usually, one sets up the following function constant before:
+ * <pre>
+ * const indent = indentWith("  ")
+ * </pre>
+ */
+export var indentWith = function (singleIndentation) {
+    return function (indentLevel) {
+        if (indentLevel === void 0) { indentLevel = 1; }
+        var prefix = repeat(singleIndentation, indentLevel);
+        var indenter = function (line) { return line.length > 0 ? (prefix + line) : line; };
+        return function () {
+            var templates = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                templates[_i] = arguments[_i];
+            }
+            return flattened(templates).map(indenter);
+        }; // Note: Template[] has type Template as well!
+    };
+};
+/**
+ * An enumeration of common indentation styles.
+ * Use these in a type-safe way as follows, e.g. for “1 tab”:
+ *
+ * ```
+ * const indent = indentWith(commonIndentations["1 tab"])
+ *
+ * indent([`foo`])
+ * ```
+ */
+export var commonIndentations = {
+    "2 spaces": "  ",
+    "4 spaces": "    ",
+    "1 tab": "\t"
+};
+//# sourceMappingURL=indents.js.map

package/dist/indents.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"indents.js","sourceRoot":"","sources":["../src/indents.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAC,SAAS,EAAE,MAAM,EAAW,MAAM,qBAAqB,CAAA;AAE/D;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,IAAM,UAAU,GAAG,UAAC,iBAAyB;IAChD,OAAA,UAAC,WAAuB;QAAvB,4BAAA,EAAA,eAAuB;QACpB,IAAM,MAAM,GAAG,MAAM,CAAC,iBAAiB,EAAE,WAAW,CAAC,CAAA;QACrD,IAAM,QAAQ,GAAG,UAAC,IAAY,IAAK,OAAA,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,EAAxC,CAAwC,CAAA;QAC3E,OAAO;YAAC,mBAAwB;iBAAxB,UAAwB,EAAxB,qBAAwB,EAAxB,IAAwB;gBAAxB,8BAAwB;;YAC5B,OAAA,SAAS,CAAC,SAAS,CAAC,CAAC,GAAG,CAAC,QAAQ,CAAC;QAAlC,CAAkC,CAAA,CAAI,8CAA8C;IAC5F,CAAC;AALD,CAKC,CAAA;AAEL;;;;;;;;;GASG;AACH,MAAM,CAAC,IAAM,kBAAkB,GAAG;IAC9B,UAAU,EAAE,IAAI;IAChB,UAAU,EAAE,MAAM;IAClB,OAAO,EAAE,IAAI;CACP,CAAA"}

package/dist/index-internal.d.ts

@@ -0,0 +1,15 @@
+export * from "./eol.js";
+export * from "./functions.js";
+export * from "./indents.js";
+export * from "./primitives.js";
+export * from "./strings.js";
+export * from "./types.js";
+/**
+ * To avoid problems with circular dependencies between JavaScript – i.e.: transpiled TypeScript – files,
+ * members in any .ts file *must* be imported through this index-internal.ts, e.g.:
+ *
+ * `import {asString} from "./index-internal.js"`
+ *
+ * (Mind the .js extension!)
+ */
+//# sourceMappingURL=index-internal.d.ts.map

package/dist/index-internal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-internal.d.ts","sourceRoot":"","sources":["../src/index-internal.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAA;AACxB,cAAc,gBAAgB,CAAA;AAC9B,cAAc,cAAc,CAAA;AAC5B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,cAAc,CAAA;AAC5B,cAAc,YAAY,CAAA;AAE1B;;;;;;;GAOG"}

package/dist/index-internal.js

@@ -0,0 +1,15 @@
+export * from "./eol.js";
+export * from "./functions.js";
+export * from "./indents.js";
+export * from "./primitives.js";
+export * from "./strings.js";
+export * from "./types.js";
+/**
+ * To avoid problems with circular dependencies between JavaScript – i.e.: transpiled TypeScript – files,
+ * members in any .ts file *must* be imported through this index-internal.ts, e.g.:
+ *
+ * `import {asString} from "./index-internal.js"`
+ *
+ * (Mind the .js extension!)
+ */
+//# sourceMappingURL=index-internal.js.map

package/dist/index-internal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-internal.js","sourceRoot":"","sources":["../src/index-internal.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAA;AACxB,cAAc,gBAAgB,CAAA;AAC9B,cAAc,cAAc,CAAA;AAC5B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,cAAc,CAAA;AAC5B,cAAc,YAAY,CAAA;AAE1B;;;;;;;GAOG"}

package/dist/index.d.ts

@@ -1,4 +1,3 @@
-export { Template, NestedString } from "./types.js";
-export { asString, indentWith, when, withNewlineAppended } from "./functions.js";
-export { commaSeparated } from "./string-utils.js";
+export { asString, commaSeparated, commonIndentations, indentWith, setEOLStyleFromOS, when, withEmptyLineAppended, withNewlineAppended } from "./index-internal.js";
+export type { Template, NestedString } from "./index-internal.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,QAAQ,EAAE,YAAY,EAAC,MAAM,YAAY,CAAA;AACjD,OAAO,EAAC,QAAQ,EAAE,UAAU,EAAE,IAAI,EAAE,mBAAmB,EAAC,MAAM,gBAAgB,CAAA;AAC9E,OAAO,EAAC,cAAc,EAAC,MAAM,mBAAmB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,QAAQ,EACR,cAAc,EACd,kBAAkB,EAClB,UAAU,EACV,iBAAiB,EACjB,IAAI,EACJ,qBAAqB,EACrB,mBAAmB,EACtB,MAAM,qBAAqB,CAAA;AAC5B,YAAY,EACR,QAAQ,EACR,YAAY,EACf,MAAM,qBAAqB,CAAA"}

package/dist/index.js

@@ -1,3 +1,3 @@
-export { asString, indentWith, when, withNewlineAppended } from "./functions.js";
-export { commaSeparated } from "./string-utils.js";
+export { asString, commaSeparated, commonIndentations, indentWith, setEOLStyleFromOS, when, withEmptyLineAppended, withNewlineAppended // (legacy alias)
+ } from "./index-internal.js";
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,QAAQ,EAAE,UAAU,EAAE,IAAI,EAAE,mBAAmB,EAAC,MAAM,gBAAgB,CAAA;AAC9E,OAAO,EAAC,cAAc,EAAC,MAAM,mBAAmB,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,QAAQ,EACR,cAAc,EACd,kBAAkB,EAClB,UAAU,EACV,iBAAiB,EACjB,IAAI,EACJ,qBAAqB,EACrB,mBAAmB,CAAK,iBAAiB;EAC5C,MAAM,qBAAqB,CAAA"}

package/dist/primitives.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Primitive functions on the {@link Template} type.
+ */
+import { Template } from "./index-internal.js";
+/**
+ * “Flattens” the given template to an array of strings, each of which represent exactly one line.
+ * Note: doesn't need to be exposed.
+ */
+export declare const flattened: (template: Template) => string[];
+/**
+ * @returns {string} - the given template joined as one string, taking care of proper EOLs.
+ */
+export declare const asString: (template: Template) => string;
+//# sourceMappingURL=primitives.d.ts.map

package/dist/primitives.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"primitives.d.ts","sourceRoot":"","sources":["../src/primitives.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAM,QAAQ,EAAC,MAAM,qBAAqB,CAAA;AAIjD;;;GAGG;AACH,eAAO,MAAM,SAAS,aAAc,QAAQ,KAAG,MAAM,EAQpD,CAAA;AAGD;;GAEG;AACH,eAAO,MAAM,QAAQ,aAAc,QAAQ,KAAG,MACY,CAAA"}

package/dist/primitives.js

@@ -0,0 +1,34 @@
+/**
+ * Primitive functions on the {@link Template} type.
+ */
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { eol } from "./index-internal.js";
+var eolRegex = new RegExp(/\r*\n/);
+/**
+ * “Flattens” the given template to an array of strings, each of which represent exactly one line.
+ * Note: doesn't need to be exposed.
+ */
+export var flattened = function (template) {
+    if (typeof template === "function") {
+        return flattened(template());
+    }
+    if (Array.isArray(template)) {
+        return template.map(flattened).reduce(function (arrL, arrR) { return __spreadArray(__spreadArray([], arrL, true), arrR, true); }, []);
+    }
+    return template.split(eolRegex);
+};
+/**
+ * @returns {string} - the given template joined as one string, taking care of proper EOLs.
+ */
+export var asString = function (template) {
+    return flattened(template).map(function (line) { return line + eol; }).join("");
+};
+//# sourceMappingURL=primitives.js.map

package/dist/primitives.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"primitives.js","sourceRoot":"","sources":["../src/primitives.ts"],"names":[],"mappings":"AAAA;;GAEG;;;;;;;;;;AAEH,OAAO,EAAC,GAAG,EAAW,MAAM,qBAAqB,CAAA;AAEjD,IAAM,QAAQ,GAAG,IAAI,MAAM,CAAC,OAAO,CAAC,CAAA;AAEpC;;;GAGG;AACH,MAAM,CAAC,IAAM,SAAS,GAAG,UAAC,QAAkB;IACxC,IAAI,OAAO,QAAQ,KAAK,UAAU,EAAE,CAAC;QACjC,OAAO,SAAS,CAAC,QAAQ,EAAE,CAAC,CAAA;IAChC,CAAC;IACD,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC1B,OAAO,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,UAAC,IAAI,EAAE,IAAI,IAAK,uCAAI,IAAI,SAAK,IAAI,SAAjB,CAAkB,EAAE,EAAE,CAAC,CAAA;IACjF,CAAC;IACD,OAAO,QAAQ,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAA;AACnC,CAAC,CAAA;AAGD;;GAEG;AACH,MAAM,CAAC,IAAM,QAAQ,GAAG,UAAC,QAAkB;IACvC,OAAA,SAAS,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,UAAC,IAAI,IAAK,OAAA,IAAI,GAAG,GAAG,EAAV,CAAU,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC;AAAtD,CAAsD,CAAA"}

package/dist/{string-utils.d.ts → strings.d.ts}

@@ -1,13 +1,14 @@
+/**
+ * Purely string-related functions.
+ */
 /**
  * @return the given array of strings but with commas added after each string except the last one.
  */
 export declare const commaSeparated: (strings: string[]) => string[];
 /**
  * Polyfill/shim for ES2015's String.prototype.repeat which doesn't work for some reason in the test...
+ * (Implementation uses the binary representation of n.)
+ * Note: doesn't need to be exposed.
  */
 export declare const repeat: (str: string, n: number) => string;
-/**
- * Ensures that the given string ends with a newline (`\n`), adding one if necessary.
- */
-export declare const withNewlineEnsured: (str: string) => string;
-//# sourceMappingURL=string-utils.d.ts.map
+//# sourceMappingURL=strings.d.ts.map

package/dist/strings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strings.d.ts","sourceRoot":"","sources":["../src/strings.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;GAEG;AACH,eAAO,MAAM,cAAc,YAAa,MAAM,EAAE,aACiC,CAAA;AAEjF;;;;GAIG;AACH,eAAO,MAAM,MAAM,QAAS,MAAM,KAAK,MAAM,KAAG,MAY/C,CAAA"}

package/dist/{string-utils.js → strings.js}

@@ -1,3 +1,6 @@
+/**
+ * Purely string-related functions.
+ */
 /**
  * @return the given array of strings but with commas added after each string except the last one.
  */
@@ -6,6 +9,8 @@ export var commaSeparated = function (strings) {
 };
 /**
  * Polyfill/shim for ES2015's String.prototype.repeat which doesn't work for some reason in the test...
+ * (Implementation uses the binary representation of n.)
+ * Note: doesn't need to be exposed.
  */
 export var repeat = function (str, n) {
     var result = "";
@@ -20,12 +25,5 @@ export var repeat = function (str, n) {
     }
     return result;
 };
-/**
- * Ensures that the given string ends with a newline (`\n`), adding one if necessary.
- */
-export var withNewlineEnsured = function (str) {
-    return str.charAt(str.length - 1) === '\n'
-        ? str
-        : (str + "\n");
-};
-//# sourceMappingURL=string-utils.js.map
+// TODO  more common string utils, e.g. withFirst{Upper|Lower}, etc.
+//# sourceMappingURL=strings.js.map

package/dist/strings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"strings.js","sourceRoot":"","sources":["../src/strings.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;GAEG;AACH,MAAM,CAAC,IAAM,cAAc,GAAG,UAAC,OAAiB;IAC5C,OAAA,OAAO,CAAC,GAAG,CAAC,UAAC,GAAG,EAAE,KAAK,IAAK,OAAA,UAAG,GAAG,SAAG,KAAK,GAAG,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAE,EAAhD,CAAgD,CAAC;AAA7E,CAA6E,CAAA;AAEjF;;;;GAIG;AACH,MAAM,CAAC,IAAM,MAAM,GAAG,UAAC,GAAW,EAAE,CAAS;IACzC,IAAI,MAAM,GAAG,EAAE,CAAA;IACf,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;QACX,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;YACd,MAAM,IAAI,GAAG,CAAA;QACjB,CAAC;QACD,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;YACR,GAAG,IAAI,GAAG,CAAA;QACd,CAAC;QACD,CAAC,KAAK,CAAC,CAAA;IACX,CAAC;IACD,OAAO,MAAM,CAAA;AACjB,CAAC,CAAA;AAGD,oEAAoE"}

package/dist/types.d.ts

@@ -1,12 +1,15 @@
+/**
+ * Types for templates.
+ */
 /**
  * A type definition for “templates” that consist of a string, or an array of templates, or a thunk returning a template.
  * Note that nesting can occur to arbitrary (finite) depth.
  *
  * @since version 0.3.0
  */
-export type Template = string | Array<Template> | (() => Template);
+export type Template = string | (() => Template) | Array<Template>;
 /**
- * An alias for the {@link Template} type definition.
+ * Legacy alias for the {@link Template} type definition.
  * Note: this type might be deprecated and removed (per a major version) in the future.
  */
 export type NestedString = Template;

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,MAAM,QAAQ,CAAC,CAAA;AAElE;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,QAAQ,CAAA"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,CAAC,MAAM,QAAQ,CAAC,GAAG,KAAK,CAAC,QAAQ,CAAC,CAAA;AAElE;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,QAAQ,CAAA"}

package/dist/types.js

@@ -1,2 +1,5 @@
+/**
+ * Types for templates.
+ */
 export {};
 //# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "littoral-templates",
-    "version": "0.4.0-rc.1",
+    "version": "0.4.0-rc.3",
     "description": "A small JavaScript/TypeScript framework to do templating comfortably using the template literal syntax in either JavaScript or TypeScript.",
     "type": "module",
     "main": "dist/index.js",
@@ -13,10 +13,12 @@
         "test": "mocha dist/test/*.js",
         "watch-test": "mocha --watch dist/test/*.js",
         "lint": "eslint src",
-        "pre-release-either": "npm run clean && npm install && npm test",
-        "prerelease": "npm run pre-release-either",
+        "prep:pre-release": "npm run clean && npm install && npm test",
+        "prerelease": "npm run prep:pre-release",
         "release": "npm publish",
-        "prerelease-beta": "npm run pre-release-either",
+        "prerelease-alpha": "npm run prep:pre-release",
+        "release-alpha": "npm publish --tag beta",
+        "prerelease-beta": "npm run prep:pre-release",
         "release-beta": "npm publish --tag beta"
     },
     "repository": {
@@ -34,12 +36,12 @@
     },
     "homepage": "https://github.com/dslmeinte/littoral-templates#readme",
     "devDependencies": {
-        "@types/chai": "5.0.1",
+        "@types/chai": "5.2.2",
         "@types/mocha": "10.0.10",
-        "@types/node": "18.19.68",
+        "@types/node": "18.19.112",
         "@typescript-eslint/eslint-plugin": "6.21.0",
         "@typescript-eslint/parser": "6.21.0",
-        "chai": "5.1.2",
+        "chai": "5.2.0",
         "mocha": "10.8.2",
         "typescript": "5.3.3"
     }

package/dist/string-utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"string-utils.d.ts","sourceRoot":"","sources":["../src/string-utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,cAAc,YAAa,MAAM,EAAE,aACiC,CAAA;AAEjF;;GAEG;AACH,eAAO,MAAM,MAAM,QAAS,MAAM,KAAK,MAAM,KAAG,MAY/C,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB,QAAS,MAAM,KAAG,MAG1B,CAAA"}

package/dist/string-utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"string-utils.js","sourceRoot":"","sources":["../src/string-utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,CAAC,IAAM,cAAc,GAAG,UAAC,OAAiB;IAC5C,OAAA,OAAO,CAAC,GAAG,CAAC,UAAC,GAAG,EAAE,KAAK,IAAK,OAAA,UAAG,GAAG,SAAG,KAAK,GAAG,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAE,EAAhD,CAAgD,CAAC;AAA7E,CAA6E,CAAA;AAEjF;;GAEG;AACH,MAAM,CAAC,IAAM,MAAM,GAAG,UAAC,GAAW,EAAE,CAAS;IACzC,IAAI,MAAM,GAAG,EAAE,CAAA;IACf,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;QACX,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;YACd,MAAM,IAAI,GAAG,CAAA;QACjB,CAAC;QACD,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;YACR,GAAG,IAAI,GAAG,CAAA;QACd,CAAC;QACD,CAAC,KAAK,CAAC,CAAA;IACX,CAAC;IACD,OAAO,MAAM,CAAA;AACjB,CAAC,CAAA;AAED;;GAEG;AACH,MAAM,CAAC,IAAM,kBAAkB,GAAG,UAAC,GAAW;IAC1C,OAAA,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,IAAI;QAC/B,CAAC,CAAC,GAAG;QACL,CAAC,CAAC,CAAE,GAAG,GAAG,IAAI,CAAC;AAFnB,CAEmB,CAAA"}