littoral-templates 0.3.0 → 0.4.0-rc.1

package/.editorconfig

@@ -0,0 +1,9 @@
+# Help: https://EditorConfig.org`
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+indent_style = space
+indent_size = 4
+

package/.eslintrc.cjs

@@ -0,0 +1,15 @@
+/* eslint-env node */
+module.exports = {
+    extends: ["eslint:recommended", "plugin:@typescript-eslint/recommended"],
+    parser: "@typescript-eslint/parser",
+    plugins: ["@typescript-eslint"],
+    root: true,
+    rules: {
+        "@typescript-eslint/no-unused-vars": ["error", {"argsIgnorePattern": "^_"}],
+        "@typescript-eslint/ban-ts-ignore": "off",
+        "@typescript-eslint/prefer-spread": ["off"]
+    },
+    env: {
+        browser: true,
+        node: true
+    }}

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # CHANGELOG
 
+## 0.4.0
+
+* 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.
+
 
 ## 0.3.0
 

package/dist/functions.d.ts

@@ -0,0 +1,55 @@
+import { Template } from "./types.js";
+/**
+ * @returns {string} - the given template joined as one string, taking care of proper newline endings.
+ */
+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[];
+/**
+ * Allows for the following syntax:
+ * <pre>
+ * [
+ *     when(<some boolean condition>)(
+ *      <stuff to include when boolean condition is true>
+ *     )
+ * ]
+ * </pre>
+ *
+ * and
+ *
+ * <pre>
+ * [
+ *     when(<some boolean condition>)(
+ *      () => <stuff to include when boolean condition is true>
+ *     )
+ * ]
+ * </pre>
+ *
+ * In the latter case, it's guaranteed that the thunk ({@see https://en.wikipedia.org/wiki/Thunk})
+ * is only evaluated (/run) when the boolean condition is true.
+ * That is useful in case the stuff to include produces side effects.
+ *
+ * Note that the second Curried argument is variadic, so it doesn't require array brackets (`[]`).
+ */
+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".
+ */
+export declare const withNewlineAppended: <T>(templateFunc: (t: T) => Template) => (t: T) => Template[];
+//# sourceMappingURL=functions.d.ts.map

package/dist/functions.d.ts.map

@@ -0,0 +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"}

package/dist/functions.js

@@ -0,0 +1,103 @@
+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>
+ */
+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!
+    };
+};
+/**
+ * Allows for the following syntax:
+ * <pre>
+ * [
+ *     when(<some boolean condition>)(
+ *      <stuff to include when boolean condition is true>
+ *     )
+ * ]
+ * </pre>
+ *
+ * and
+ *
+ * <pre>
+ * [
+ *     when(<some boolean condition>)(
+ *      () => <stuff to include when boolean condition is true>
+ *     )
+ * ]
+ * </pre>
+ *
+ * In the latter case, it's guaranteed that the thunk ({@see https://en.wikipedia.org/wiki/Thunk})
+ * is only evaluated (/run) when the boolean condition is true.
+ * That is useful in case the stuff to include produces side effects.
+ *
+ * Note that the second Curried argument is variadic, so it doesn't require array brackets (`[]`).
+ */
+export var when = function (bool) {
+    return bool
+        ? function () {
+            var whenResults = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                whenResults[_i] = arguments[_i];
+            }
+            return flatten(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".
+ */
+export var withNewlineAppended = function (templateFunc) {
+    return function (t) { return [templateFunc(t), ""]; };
+};
+//# sourceMappingURL=functions.js.map

package/dist/functions.js.map

@@ -0,0 +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"}

package/dist/index.d.ts

@@ -1,69 +1,4 @@
-/**
- * A type definition for “templates” that consist of array of strings nested to an arbitrary depth.
- * (Depth 0 corresponds to just a single string.)
- *
- * @since version 0.3.0
- */
-export type Template = string | Array<Template>;
-/**
- * An 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;
-type TemplateFunction<T> = (_: Template) => T;
-/**
- * @returns {string} - the given template joined as one string, taking care of proper newline endings.
- */
-export declare const asString: (template: Template) => string;
-/**
- * @returns {function} - 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>
- *
- * Usually, one sets up the following function constant before:
- * <pre>
- * const indent = indentWith("  ")
- * </pre>
- */
-export declare const indentWith: (singleIndentation: string) => (indentLevel?: number) => TemplateFunction<string[]>;
-/**
- * Allows for the following syntax:
- * <pre>
- * [
- *     when(<some boolean condition>)(
- *      <stuff to include when boolean condition is true>
- *     )
- * ]
- * </pre>
- *
- * and
- *
- * <pre>
- * [
- *     when(<some boolean condition>)(
- *      () => <stuff to include when boolean condition is true>
- *     )
- * ]
- * </pre>
- *
- * In the latter case, it's guaranteed that the thunk ({@see https://en.wikipedia.org/wiki/Thunk})
- * is only evaluated (/run) when the boolean condition is true.
- * That is useful in case the stuff to include produces side effects.
- */
-export declare const when: (bool: boolean) => (whenResult: (() => Template) | Template) => Template;
-/**
- * @return a function that composes the given template function with the action of "adding a newline after".
- */
-export declare const withNewlineAppended: <T>(templateFunc: (t: T) => Template) => (t: T) => Template[];
-/**
- * @return the given array of strings but with commas added after each string except the last one.
- */
-export declare const commaSeparated: (strings: string[]) => string[];
-export {};
+export { Template, NestedString } from "./types.js";
+export { asString, indentWith, when, withNewlineAppended } from "./functions.js";
+export { commaSeparated } from "./string-utils.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;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,KAAK,CAAC,QAAQ,CAAC,CAAA;AAE/C;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,QAAQ,CAAA;AAGnC,KAAK,gBAAgB,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,QAAQ,KAAK,CAAC,CAAA;AA6B7C;;GAEG;AACH,eAAO,MAAM,QAAQ,aAdN,QAAQ,WAc2F,CAAA;AAoBlH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,UAAU,sBAAuB,MAAM,oBAClC,MAAM,KAAO,gBAAgB,CAAC,MAAM,EAAE,CAInD,CAAA;AAGL;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,IAAI,SAAU,OAAO,kBAEX,CAAC,MAAM,QAAQ,CAAC,GAAG,QAAQ,aAIQ,CAAA;AAG1D;;GAEG;AACH,eAAO,MAAM,mBAAmB,GAAI,CAAC,gBAAgB,CAAC,CAAC,EAAE,CAAC,KAAK,QAAQ,SAC/D,CAAC,eAA0B,CAAA;AAGnC;;GAEG;AACH,eAAO,MAAM,cAAc,YAAa,MAAM,EAAE,aACiC,CAAA"}
+{"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"}

package/dist/index.js

@@ -1,124 +1,3 @@
-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));
-};
-/**
- * Polyfill/shim for ES2019's Array.prototype.flat(..).
- */
-var flatten = function (template) {
-    return Array.isArray(template)
-        ? template.map(flatten).reduce(function (arrL, arrR) { return __spreadArray(__spreadArray([], arrL, true), arrR, true); }, [])
-        : [template];
-};
-/**
- * @returns {function(*=): *} - a function that maps over a single string using mapString, or an array of strings using mapStrings.
- * If an array is given, that array is completely (i.e.: recursively) flattened first, before the mapStrings function is applied.
- * (This function is only used internally.)
- */
-var mapNestedString = function (mapString, mapStrings) {
-    return function (template) {
-        return Array.isArray(template)
-            ? mapStrings(flatten(template))
-            : mapString(template);
-    };
-};
-var withNewlineEnsured = function (str) {
-    return str.charAt(str.length - 1) === '\n'
-        ? str
-        : (str + "\n");
-};
-/**
- * @returns {string} - the given template joined as one string, taking care of proper newline endings.
- */
-export var asString = mapNestedString(withNewlineEnsured, function (strings) { return strings.map(withNewlineEnsured).join(""); });
-/**
- * Polyfill/shim for ES2015's String.prototype.repeat which doesn't work for some reason in the test...
- */
-var repeat = function (str, n) {
-    var result = "";
-    while (n > 0) {
-        if (n % 2 === 1) {
-            result += str;
-        }
-        if (n > 1) {
-            str += str;
-        }
-        n >>= 1;
-    }
-    return result;
-};
-/**
- * @returns {function} - 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>
- *
- * 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 indentationPrefix = repeat(singleIndentation, indentLevel);
-        var indentLine = function (str) { return str.split("\n").map(function (line) { return (line.length > 0 ? indentationPrefix : "") + line; }).join("\n"); };
-        return mapNestedString(function (string) { return [indentLine(string)]; }, function (strings) { return strings.map(indentLine); });
-    };
-};
-/**
- * Allows for the following syntax:
- * <pre>
- * [
- *     when(<some boolean condition>)(
- *      <stuff to include when boolean condition is true>
- *     )
- * ]
- * </pre>
- *
- * and
- *
- * <pre>
- * [
- *     when(<some boolean condition>)(
- *      () => <stuff to include when boolean condition is true>
- *     )
- * ]
- * </pre>
- *
- * In the latter case, it's guaranteed that the thunk ({@see https://en.wikipedia.org/wiki/Thunk})
- * is only evaluated (/run) when the boolean condition is true.
- * That is useful in case the stuff to include produces side effects.
- */
-export var when = function (bool) {
-    return bool
-        ? function (whenResult) {
-            return typeof whenResult === "function"
-                ? whenResult()
-                : whenResult;
-        }
-        : function (_whenResult) { return []; };
-};
-/**
- * @return a function that composes the given template function with the action of "adding a newline after".
- */
-export var withNewlineAppended = function (templateFunc) {
-    return function (t) { return [templateFunc(t), ""]; };
-};
-/**
- * @return the given array of strings but with commas added after each string except the last one.
- */
-export var commaSeparated = function (strings) {
-    return strings.map(function (str, index) { return "".concat(str).concat(index + 1 < strings.length ? "," : ""); });
-};
+export { asString, indentWith, when, withNewlineAppended } from "./functions.js";
+export { commaSeparated } from "./string-utils.js";
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"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"}

package/dist/string-utils.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @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...
+ */
+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

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,31 @@
+/**
+ * @return the given array of strings but with commas added after each string except the last one.
+ */
+export var commaSeparated = function (strings) {
+    return strings.map(function (str, index) { return "".concat(str).concat(index + 1 < strings.length ? "," : ""); });
+};
+/**
+ * Polyfill/shim for ES2015's String.prototype.repeat which doesn't work for some reason in the test...
+ */
+export var repeat = function (str, n) {
+    var result = "";
+    while (n > 0) {
+        if (n % 2 === 1) {
+            result += str;
+        }
+        if (n > 1) {
+            str += str;
+        }
+        n >>= 1;
+    }
+    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

package/dist/string-utils.js.map

@@ -0,0 +1 @@
+{"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"}

package/dist/types.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 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);
+/**
+ * An 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;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +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"}

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

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

package/package.json

@@ -1,39 +1,46 @@
 {
-  "name": "littoral-templates",
-  "version": "0.3.0",
-  "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",
-  "types": "dist/index.d.ts",
-  "scripts": {
-    "build": "tsc",
-    "watch-build": "tsc --watch",
-    "clean": "rm -rf dist",
-    "pretest": "npm-run-all build",
-    "test": "mocha dist/test/*.js",
-    "watch-test": "mocha --watch dist/test/*.js"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/dslmeinte/littoral-templates.git"
-  },
-  "keywords": [
-    "template",
-    "engine"
-  ],
-  "author": "Meinte Boersma",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/dslmeinte/littoral-templates/issues"
-  },
-  "homepage": "https://github.com/dslmeinte/littoral-templates#readme",
-  "devDependencies": {
-    "@types/chai": "5.0.1",
-    "@types/mocha": "10.0.9",
-    "@types/node": "18.19.64",
-    "chai": "5.1.2",
-    "mocha": "10.8.2",
-    "npm-run-all": "4.1.5",
-    "typescript": "5.6.3"
-  }
+    "name": "littoral-templates",
+    "version": "0.4.0-rc.1",
+    "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",
+    "types": "dist/index.d.ts",
+    "scripts": {
+        "build": "tsc",
+        "watch-build": "tsc --watch",
+        "clean": "rm -rf dist node_modules",
+        "pretest": "npm run build",
+        "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",
+        "release": "npm publish",
+        "prerelease-beta": "npm run pre-release-either",
+        "release-beta": "npm publish --tag beta"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/dslmeinte/littoral-templates.git"
+    },
+    "keywords": [
+        "template",
+        "engine"
+    ],
+    "author": "Meinte Boersma",
+    "license": "MIT",
+    "bugs": {
+        "url": "https://github.com/dslmeinte/littoral-templates/issues"
+    },
+    "homepage": "https://github.com/dslmeinte/littoral-templates#readme",
+    "devDependencies": {
+        "@types/chai": "5.0.1",
+        "@types/mocha": "10.0.10",
+        "@types/node": "18.19.68",
+        "@typescript-eslint/eslint-plugin": "6.21.0",
+        "@typescript-eslint/parser": "6.21.0",
+        "chai": "5.1.2",
+        "mocha": "10.8.2",
+        "typescript": "5.3.3"
+    }
 }