@lana-commerce/core 11.0.0

package/cjs/slate.js

@@ -0,0 +1,376 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toHTML = exports.nodesToHTML = exports.extractHeaders = exports.extractTextFromParagraphs = exports.extractText = exports.isEmpty = exports.split = exports.splitIntoNamed = void 0;
+const tslib_1 = require("tslib");
+const escape_html_1 = tslib_1.__importDefault(require("escape-html"));
+const buildconfig_js_1 = require("./buildconfig.js");
+const convertImageURL_js_1 = require("./convertImageURL.js");
+const splitBy_js_1 = require("./splitBy.js");
+const PREFIX = buildconfig_js_1.BUILD_CONFIG.SLATE_CLASS_PREFIX;
+const markConfig = {
+    bold: { begin: "<strong>", end: "</strong>" },
+    code: { begin: "<code>", end: "</code>" },
+    italic: { begin: "<em>", end: "</em>" },
+    underlined: { begin: "<u>", end: "</u>" },
+    strikethrough: { begin: "<del>", end: "</del>" },
+};
+function calcTextLength(n) {
+    let len = 0;
+    if (n.leaves) {
+        for (const l of n.leaves) {
+            len += l.text.length;
+        }
+    }
+    if (n.nodes) {
+        for (const node of n.nodes) {
+            len += calcTextLength(node);
+        }
+    }
+    return len;
+}
+function extractTextFromNodeImpl(buf, n) {
+    if (n.leaves) {
+        for (const l of n.leaves) {
+            buf.push(l.text);
+        }
+    }
+    if (n.nodes) {
+        for (const node of n.nodes) {
+            extractTextFromNodeImpl(buf, node);
+        }
+    }
+}
+function extractTextFromNode(n) {
+    const buf = [];
+    extractTextFromNodeImpl(buf, n);
+    return buf.join(" ");
+}
+function serializeLeaf(_ctx, buf, leaf) {
+    if (leaf.marks) {
+        for (const m of leaf.marks) {
+            const v = markConfig[m.type];
+            if (v)
+                buf.push(v.begin);
+        }
+    }
+    buf.push((0, escape_html_1.default)(leaf.text));
+    if (leaf.marks) {
+        for (const m of leaf.marks) {
+            const v = markConfig[m.type];
+            if (v)
+                buf.push(v.end);
+        }
+    }
+}
+function serializeText(ctx, buf, n) {
+    if (n.leaves) {
+        for (const leaf of n.leaves) {
+            serializeLeaf(ctx, buf, leaf);
+        }
+    }
+}
+function serializeInline(ctx, buf, n) {
+    if (n.type === "link") {
+        const beg = `<a href="${n.data.href || ""}">`;
+        const end = `</a>`;
+        wrap(buf, beg, serializeNodesFunc(ctx, buf, n.nodes), end);
+    }
+    else if (n.type === "emoji") {
+        // TODO
+    }
+}
+function imageDataSizeToStyle(img, m) {
+    m["width"] = "100%";
+    m["max-width"] = `${Math.max(16, img.width)}px`;
+    m["height"] = `${Math.max(16, img.height)}px`;
+}
+function imageDataAlignToStyle(img, m) {
+    if (img.align === "left") {
+        m["margin-left"] = "0";
+        m["margin-right"] = "auto";
+    }
+    else if (img.align === "center") {
+        m["margin-left"] = "auto";
+        m["margin-right"] = "auto";
+    }
+    else if (img.align === "right") {
+        m["margin-left"] = "auto";
+        m["margin-right"] = "0";
+    }
+    else if (img.align === "floatLeft") {
+        m["float"] = "left";
+        m["margin"] = "15px 15px 15px 0";
+    }
+    else if (img.align === "floatRight") {
+        m["float"] = "right";
+        m["margin"] = "15px 0 15px 15px";
+    }
+    else if (img.align === "fullWidth") {
+        if (img.locked) {
+            const w = Math.max(1, img.lockedW);
+            const h = Math.max(1, img.lockedH);
+            const p = `${((h / w) * 100).toFixed(2)}%`;
+            m["width"] = "100%";
+            m["padding-bottom"] = p;
+            m["max-width"] = "none";
+        }
+        else {
+            m["width"] = "100%";
+            m["max-width"] = "none";
+            m["height"] = `${Math.max(16, img.height)}px`;
+        }
+    }
+}
+function imageDataCropToStyle(img, m) {
+    if (img.crop === "") {
+        return;
+    }
+    m["background-size"] = "cover";
+    if (img.crop === "center") {
+        m["background-position"] = "center center";
+    }
+    else if (img.crop === "top") {
+        m["background-position"] = "center 0%";
+    }
+    else if (img.crop === "top-left") {
+        m["background-position"] = "0% 0%";
+    }
+    else if (img.crop === "top-right") {
+        m["background-position"] = "100% 0%";
+    }
+    else if (img.crop === "bottom") {
+        m["background-position"] = "center 100%";
+    }
+    else if (img.crop === "bottom-left") {
+        m["background-position"] = "0% 100%";
+    }
+    else if (img.crop === "bottom-right") {
+        m["ackground-position"] = "100% 100%";
+    }
+    else if (img.crop === "left") {
+        m["background-position"] = "0% center";
+    }
+    else if (img.crop === "right") {
+        m["background-position"] = "100% center";
+    }
+}
+function stylesMapToString(m) {
+    return Object.keys(m)
+        .sort()
+        .map((k) => `${k}: ${m[k]}`)
+        .join("; ");
+}
+function imageData(n) {
+    return {
+        align: n.data.align,
+        crop: n.data.crop,
+        fileID: n.data.fileID,
+        locked: n.data.locked,
+        width: n.data.width,
+        height: n.data.height,
+        lockedW: n.data.lockedW,
+        lockedH: n.data.lockedH,
+        src: n.data.src,
+    };
+}
+const topLevelHeaderMaybe = (ctx) => (ctx.lastTopLevelHeader ? `,id-${ctx.lastTopLevelHeader}` : "");
+function serializeBlock(ctx, buf, n) {
+    if (n.type === "h1") {
+        ctx.counter++;
+        ctx.lastTopLevelHeader = ctx.counter;
+        wrap(buf, `<h1 data-anchor="id-${ctx.counter}">`, serializeNodesFunc(ctx, buf, n.nodes), `</h1>`);
+    }
+    else if (n.type === "h2") {
+        wrap(buf, `<h2 data-anchor="id-${++ctx.counter}${topLevelHeaderMaybe(ctx)}">`, serializeNodesFunc(ctx, buf, n.nodes), `</h2>`);
+    }
+    else if (n.type === "h3") {
+        wrap(buf, `<h3 data-anchor="id-${++ctx.counter}${topLevelHeaderMaybe(ctx)}">`, serializeNodesFunc(ctx, buf, n.nodes), `</h3>`);
+    }
+    else if (n.type === "ol") {
+        wrap(buf, `<ol>`, serializeNodesFunc(ctx, buf, n.nodes), `</ol>`);
+    }
+    else if (n.type === "ul") {
+        wrap(buf, `<ul>`, serializeNodesFunc(ctx, buf, n.nodes), `</ul>`);
+    }
+    else if (n.type === "li") {
+        wrap(buf, `<li>`, serializeNodesFunc(ctx, buf, n.nodes), `</li>`);
+    }
+    else if (n.type === "blockquote") {
+        wrap(buf, `<blockquote>`, serializeNodesFunc(ctx, buf, n.nodes), `</blockquote>`);
+    }
+    else if (n.type === "paragraph") {
+        const pbuf = [];
+        serializeNodesFunc(ctx, pbuf, n.nodes)();
+        let beg = `<p>`;
+        const pbufData = pbuf.join("");
+        if (pbufData.length === 0) {
+            beg = `<p class="${PREFIX}content-empty-p">`;
+        }
+        wrap(buf, beg, serializeBufferFunc(buf, pbuf), `</p>`);
+    }
+    else if (n.type === "codeblock") {
+        wrap(buf, `<div class="${PREFIX}content-code">`, serializeNodesFunc(ctx, buf, n.nodes), `</div>`);
+    }
+    else if (n.type === "code") {
+        wrap(buf, `<div class="${PREFIX}content-code-line">`, serializeNodesFunc(ctx, buf, n.nodes), `</div>`);
+    }
+    else if (n.type === "image") {
+        const img = imageData(n);
+        const styles = {};
+        imageDataSizeToStyle(img, styles);
+        imageDataAlignToStyle(img, styles);
+        const imageParams = {};
+        if (img.align !== "fullWidth") {
+            imageParams.size = `${img.width}x${img.height}`;
+        }
+        if (img.crop !== "") {
+            imageParams.crop = img.crop; // TODO: is this a bug?
+        }
+        styles["background-image"] = `url('${(0, convertImageURL_js_1.convertImageURL)(ctx.cdnBaseURL, publicURL(img.fileID, ctx), imageParams)}')`;
+        styles["background-repeat"] = "no-repeat";
+        styles["background-size"] = "contain";
+        styles["background-position"] = "center";
+        imageDataCropToStyle(img, styles);
+        buf.push(`<div class="${PREFIX}content-image" style="${stylesMapToString(styles)}"></div>`);
+    }
+    else if (n.type === "video") {
+        const img = imageData(n);
+        const iframeStyles = {
+            position: "absolute",
+            top: "0",
+            left: "0",
+            width: "100%",
+            height: "100%",
+        };
+        const styles = {};
+        imageDataSizeToStyle(img, styles);
+        imageDataAlignToStyle(img, styles);
+        const iframe = `<iframe allowfullscreen style="${stylesMapToString(iframeStyles)}" frameborder="0" src="${img.src}"></iframe>`;
+        buf.push(`<div class="${PREFIX}content-video" style="${stylesMapToString(styles)}">${iframe}</div>`);
+    }
+}
+function serializeNode(ctx, buf, n) {
+    if (n.object === "block") {
+        serializeBlock(ctx, buf, n);
+    }
+    else if (n.object === "inline") {
+        serializeInline(ctx, buf, n);
+    }
+    else if (n.object === "text") {
+        serializeText(ctx, buf, n);
+    }
+}
+function serializeBufferFunc(buf, srcbuf) {
+    return () => {
+        buf.push(...srcbuf);
+    };
+}
+function serializeNodesFunc(ctx, buf, nodes) {
+    return () => {
+        if (nodes) {
+            for (const n of nodes) {
+                serializeNode(ctx, buf, n);
+            }
+        }
+    };
+}
+function wrap(buf, begin, cb, end) {
+    buf.push(begin);
+    cb();
+    buf.push(end);
+}
+function splitIntoNamed(v) {
+    const out = [];
+    const nodeGroups = split(v);
+    for (const ng of nodeGroups) {
+        const n = ng.length > 1 ? ng[0] : undefined;
+        if (n && n.object === "block" && (n.type === "h1" || n.type === "h2" || n.type === "h3")) {
+            // first node is a header, extract it into title :-)
+            out.push({ title: extractTextFromNode(n), nodes: ng.slice(1) });
+        }
+        else {
+            // no title T_T
+            out.push({ title: "", nodes: ng });
+        }
+    }
+    return out;
+}
+exports.splitIntoNamed = splitIntoNamed;
+function split(v) {
+    return (0, splitBy_js_1.splitBy)(v.document.nodes, (n) => n.type === "separator");
+}
+exports.split = split;
+function isEmpty(v) {
+    let len = 0;
+    for (const node of v.document.nodes) {
+        len += calcTextLength(node);
+    }
+    return len === 0;
+}
+exports.isEmpty = isEmpty;
+function extractText(v) {
+    return v.document.nodes.map(extractTextFromNode).join(" ");
+}
+exports.extractText = extractText;
+function extractTextFromParagraphs(v) {
+    const paragraphNodes = v.document.nodes.filter((n) => n.object === "block" && n.type === "paragraph");
+    return paragraphNodes.map(extractTextFromNode).join(" ");
+}
+exports.extractTextFromParagraphs = extractTextFromParagraphs;
+function extractHeaders(v) {
+    const headers = [];
+    let counter = 0;
+    let lastTopLevel = null;
+    for (const n of v.document.nodes) {
+        if (n.object === "block") {
+            if (n.type === "h1") {
+                lastTopLevel = {
+                    id: `id-${++counter}`,
+                    text: extractTextFromNode(n),
+                    children: [],
+                };
+                headers.push(lastTopLevel);
+            }
+            else if (n.type === "h2" && lastTopLevel) {
+                lastTopLevel.children.push({
+                    id: `id-${++counter}`,
+                    text: extractTextFromNode(n),
+                });
+            }
+            else if (n.type === "h3" && lastTopLevel) {
+                lastTopLevel.children.push({
+                    id: `id-${++counter}`,
+                    text: extractTextFromNode(n),
+                });
+            }
+        }
+    }
+    return headers;
+}
+exports.extractHeaders = extractHeaders;
+function publicURL(fileID, ctx) {
+    for (const f of ctx.contentImageFiles) {
+        if (f.id === fileID) {
+            return f.public_url;
+        }
+    }
+    return "";
+}
+function nodesToHTML(cdnBaseURL, nodes, contentImageFiles) {
+    const buf = [];
+    const ctx = {
+        cdnBaseURL,
+        lastTopLevelHeader: undefined,
+        counter: 0,
+        contentImageFiles,
+    };
+    wrap(buf, `<div class="${PREFIX}content-root">`, serializeNodesFunc(ctx, buf, nodes), `</div>`);
+    return buf.join("");
+}
+exports.nodesToHTML = nodesToHTML;
+function toHTML(cdnBaseURL, v, contentImageFiles) {
+    return split(v).map((nodes) => {
+        return nodesToHTML(cdnBaseURL, nodes, contentImageFiles);
+    });
+}
+exports.toHTML = toHTML;

package/cjs/sleep.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sleep = void 0;
+const tslib_1 = require("tslib");
+function sleep(ms) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        return new Promise((r) => setTimeout(r, ms));
+    });
+}
+exports.sleep = sleep;

package/cjs/splitBy.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitBy = void 0;
+function splitBy(v, isSep) {
+    const initial = [];
+    const state = {
+        output: [initial],
+        current: initial,
+    };
+    for (const current of v) {
+        if (isSep(current)) {
+            state.current = [];
+            state.output.push(state.current);
+        }
+        else {
+            state.current.push(current);
+        }
+    }
+    return state.output;
+}
+exports.splitBy = splitBy;

package/cjs/splitName.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initials = exports.splitName = void 0;
+const tslib_1 = require("tslib");
+const humanparser_1 = tslib_1.__importDefault(require("humanparser"));
+function splitName(name) {
+    const nm = humanparser_1.default.parseName(name);
+    if (nm.firstName && nm.lastName) {
+        return [nm.firstName, nm.lastName];
+    }
+    else if (nm.firstName) {
+        return [nm.firstName];
+    }
+    return [""];
+}
+exports.splitName = splitName;
+function initials(name) {
+    const [firstName, lastName] = splitName(name);
+    let out = "";
+    if (firstName) {
+        out += firstName.substr(0, 1).toUpperCase();
+    }
+    if (lastName) {
+        out += lastName.substr(0, 1).toUpperCase();
+    }
+    return out;
+}
+exports.initials = initials;

package/cjs/stripZeros.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripZeros = void 0;
+function stripZeros(v) {
+    const dotAt = v.indexOf(".");
+    if (dotAt === -1)
+        return v;
+    while (v.length > dotAt && (v[v.length - 1] === "0" || v[v.length - 1] === ".")) {
+        v = v.substring(0, v.length - 1);
+    }
+    return v;
+}
+exports.stripZeros = stripZeros;

package/cjs/stripeError.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchCVCErrorFromRR = exports.matchExpiryErrorFromRR = exports.matchNumberErrorFromRR = exports.matchMapFromRR = exports.matchCVCError = exports.matchExpiryError = exports.matchNumberError = exports.matchMap = void 0;
+const codes_js_1 = require("./generated/codes.js");
+const stripeNumberErrorMap = {
+    invalid_number: true,
+    incorrect_number: true,
+    incomplete_number: true,
+    card_declined: true,
+    missing: true,
+    processing_error: true,
+};
+const stripeExpiryErrorMap = {
+    invalid_expiry_month: true,
+    invalid_expiry_year: true,
+    expired_card: true,
+    incomplete_expiry: true,
+    invalid_expiry_year_past: true,
+    invalid_expiry_month_past: true,
+};
+const stripeCVCErrorMap = {
+    invalid_cvc: true,
+    incorrect_cvc: true,
+    incomplete_cvc: true,
+};
+function matchMap(map, code) {
+    return map[code] ? code : undefined;
+}
+exports.matchMap = matchMap;
+function matchNumberError(code) {
+    return matchMap(stripeNumberErrorMap, code);
+}
+exports.matchNumberError = matchNumberError;
+function matchExpiryError(code) {
+    return matchMap(stripeExpiryErrorMap, code);
+}
+exports.matchExpiryError = matchExpiryError;
+function matchCVCError(code) {
+    return matchMap(stripeCVCErrorMap, code);
+}
+exports.matchCVCError = matchCVCError;
+function matchMapFromRR(map, e) {
+    var _a, _b;
+    if (e.kind !== "error")
+        return undefined;
+    if (((_a = e.error.apiError) === null || _a === void 0 ? void 0 : _a.code) !== codes_js_1.ErrorCode.StripeAPICallFailure)
+        return undefined;
+    const code = (_b = e.error.apiError.meta) === null || _b === void 0 ? void 0 : _b.code;
+    if (!code)
+        return undefined;
+    return matchMap(map, code);
+}
+exports.matchMapFromRR = matchMapFromRR;
+function matchNumberErrorFromRR(e) {
+    return matchMapFromRR(stripeNumberErrorMap, e);
+}
+exports.matchNumberErrorFromRR = matchNumberErrorFromRR;
+function matchExpiryErrorFromRR(e) {
+    return matchMapFromRR(stripeExpiryErrorMap, e);
+}
+exports.matchExpiryErrorFromRR = matchExpiryErrorFromRR;
+function matchCVCErrorFromRR(e) {
+    return matchMapFromRR(stripeCVCErrorMap, e);
+}
+exports.matchCVCErrorFromRR = matchCVCErrorFromRR;

package/cjs/tailSplit.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tailSplit = void 0;
+function tailSplit(v, sep, n) {
+    if (n <= 0)
+        return [];
+    const arr = v.split(sep);
+    const head = arr.slice(0, n - 1);
+    const tail = arr.slice(n - 1);
+    return tail.length > 0 ? [...head, tail.join(sep)] : head;
+}
+exports.tailSplit = tailSplit;

package/cjs/tieredPrice.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tieredPrice = void 0;
+function tieredPrice(tp, price, qty, tieredQty) {
+    if (!tp) {
+        return price * qty;
+    }
+    if (tp.tiers.length === 0) {
+        return price * qty;
+    }
+    if (tp.model === "volume") {
+        for (const t of tp.tiers) {
+            if ((t.from === -1 || tieredQty >= t.from) && (t.to === -1 || tieredQty <= t.to)) {
+                return t.price !== 0 ? t.price * qty : price * qty;
+            }
+        }
+    }
+    else if (tp.model === "graduated") {
+        let sum = 0;
+        for (const t of tp.tiers) {
+            const tqty = Math.min(t.from === -1 ? t.to : t.to === -1 ? qty : t.to - t.from + 1, qty);
+            const tprice = t.price !== 0 ? t.price : price;
+            sum += tqty * tprice;
+            if (tqty === qty)
+                break;
+            qty -= tqty;
+        }
+        return sum;
+    }
+    return price * qty;
+}
+exports.tieredPrice = tieredPrice;

package/cjs/timeIt.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.timeIt = void 0;
+const tslib_1 = require("tslib");
+function timeIt(log, cb) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const t0 = +new Date();
+        const v = yield cb();
+        const t1 = +new Date();
+        const diffSeconds = (t1 - t0) / 1000;
+        log(diffSeconds);
+        return v;
+    });
+}
+exports.timeIt = timeIt;

package/cjs/toMajor.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toMajor = void 0;
+function toMajor(shopCurrencies, currencyCode, v) {
+    const c = shopCurrencies[currencyCode];
+    return c ? v / c.currency.to_minor : undefined;
+}
+exports.toMajor = toMajor;

package/cjs/toMinor.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toMinor = void 0;
+function toMinor(shopCurrencies, currencyCode, v) {
+    const c = shopCurrencies[currencyCode];
+    return c ? Math.round(v * c.currency.to_minor) : undefined;
+}
+exports.toMinor = toMinor;

package/cjs/trace.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trace = exports.traceEvents = exports.disableTrace = exports.enableTrace = void 0;
+const tslib_1 = require("tslib");
+function getTS() {
+    const hrtime = process.hrtime(); // [seconds, nanoseconds]
+    return hrtime[0] * 1000000 + Math.round(hrtime[1] / 1000); // microseconds
+}
+let idSeq = 0;
+let traceEnabled = false;
+function enableTrace() {
+    traceEnabled = true;
+}
+exports.enableTrace = enableTrace;
+function disableTrace() {
+    traceEnabled = true;
+}
+exports.disableTrace = disableTrace;
+exports.traceEvents = [];
+function trace(tid, name, pfunc) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        if (!traceEnabled) {
+            return pfunc();
+        }
+        const id = ++idSeq;
+        const common = {
+            pid: process.pid,
+            tid,
+            id,
+        };
+        exports.traceEvents.push(Object.assign(Object.assign({}, common), { name, ts: getTS(), ph: "B" }));
+        const result = yield pfunc();
+        exports.traceEvents.push(Object.assign(Object.assign({}, common), { ts: getTS(), ph: "E" }));
+        return result;
+    });
+}
+exports.trace = trace;

package/cjs/translateLocale.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setLocale = exports.getLocale = void 0;
+let globalLocale = "en";
+function getLocale() {
+    return globalLocale;
+}
+exports.getLocale = getLocale;
+function setLocale(locale) {
+    globalLocale = locale;
+}
+exports.setLocale = setLocale;

package/cjs/traverse.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traverse = void 0;
+function traverse(o, fn) {
+    if (o instanceof Buffer)
+        return; // skip buffer objects
+    for (const i in o) {
+        fn(o, i, o[i]);
+        if (o[i] !== null && typeof o[i] === "object") {
+            traverse(o[i], fn);
+        }
+    }
+}
+exports.traverse = traverse;

package/cjs/truncate.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.truncate = void 0;
+/**
+Truncate 'text' using 'min'/'max' range as a "truncation window". Prefer
+truncation on space characters. If there is one that fits into the truncation
+window. Otherwise simply break at 'max'. Inserts ellipsis ('…') if truncation
+happened. Never exceeds 'max' characters length.
+*/
+function truncate(text, min, max) {
+    if (text.length <= max) {
+        return text;
+    }
+    const trunc = text.slice(0, max);
+    const i = trunc.lastIndexOf(" ");
+    if (i > min) {
+        return trunc.slice(0, i) + "…";
+    }
+    return text.slice(0, max - 1) + "…";
+}
+exports.truncate = truncate;