@punks/backend-core 0.0.76 → 0.0.78

package/dist/cjs/index.js

@@ -440,6 +440,200 @@ const jsonSerialize = (obj, options) => {
     return JSON.stringify(obj, replacer, spaces);
 };
 
+const encodeUtf8 = (value) => Buffer.from(value).toString("utf-8");
+const decodeUtf8 = (value) => Buffer.from(value, "utf-8");
+const encodeBase64 = (value) => Buffer.from(value).toString("base64");
+const decodeBase64 = (value) => Buffer.from(value, "base64");
+
+// borrowed from https://github.com/ericnorris/striptags
+function isSpace(character) {
+    return (character == " " ||
+        character == "\n" ||
+        character == "\r" ||
+        character == "\t");
+}
+function isQuote(character) {
+    return character == '"' || character == "'";
+}
+const TAG_START = "<";
+const TAG_END = ">";
+const ENCODED_TAG_START = "&lt;";
+const ENCODED_TAG_END = "&gt;";
+class InPlaintextState {
+    constructor(options) {
+        this.options = options;
+    }
+    consume(character, transition) {
+        if (character == TAG_START) {
+            transition(new InTagNameState(this.options));
+            return "";
+        }
+        else if (character == TAG_END &&
+            this.options.encodePlaintextTagDelimiters) {
+            return ENCODED_TAG_END;
+        }
+        return character;
+    }
+}
+class InTagNameState {
+    constructor(options) {
+        this.options = options;
+        this.nameBuffer = "";
+        this.isClosingTag = false;
+    }
+    consume(character, transition) {
+        if (this.nameBuffer.length == 0) {
+            if (isSpace(character)) {
+                transition(new InPlaintextState(this.options));
+                return ((this.options.encodePlaintextTagDelimiters
+                    ? ENCODED_TAG_START
+                    : "<") + character);
+            }
+            if (character == "/") {
+                this.isClosingTag = true;
+                return "";
+            }
+        }
+        if (isSpace(character)) {
+            if (this.isNameBufferAnAllowedTag()) {
+                transition(new InTagState(0 /* TagMode.Allowed */, this.options));
+                return (TAG_START +
+                    (this.isClosingTag ? "/" : "") +
+                    this.nameBuffer +
+                    character);
+            }
+            else {
+                transition(new InTagState(1 /* TagMode.Disallowed */, this.options));
+                return this.options.tagReplacementText;
+            }
+        }
+        if (character == TAG_START) {
+            this.nameBuffer += ENCODED_TAG_START;
+            return "";
+        }
+        if (character == TAG_END) {
+            transition(new InPlaintextState(this.options));
+            if (this.isNameBufferAnAllowedTag()) {
+                return (TAG_START +
+                    (this.isClosingTag ? "/" : "") +
+                    this.nameBuffer +
+                    character);
+            }
+            else {
+                return this.options.tagReplacementText;
+            }
+        }
+        if (character == "-" && this.nameBuffer == "!-") {
+            transition(new InCommentState(this.options));
+            return "";
+        }
+        this.nameBuffer += character;
+        return "";
+    }
+    isNameBufferAnAllowedTag() {
+        const tagName = this.nameBuffer.toLowerCase();
+        if (this.options.allowedTags) {
+            return this.options.allowedTags.has(tagName);
+        }
+        else if (this.options.disallowedTags) {
+            return !this.options.disallowedTags.has(tagName);
+        }
+        else {
+            return false;
+        }
+    }
+}
+class InTagState {
+    constructor(mode, options) {
+        this.mode = mode;
+        this.options = options;
+    }
+    consume(character, transition) {
+        if (character == TAG_END) {
+            transition(new InPlaintextState(this.options));
+        }
+        else if (isQuote(character)) {
+            transition(new InQuotedStringInTagState(this.mode, character, this.options));
+        }
+        if (this.mode == 1 /* TagMode.Disallowed */) {
+            return "";
+        }
+        if (character == TAG_START) {
+            return ENCODED_TAG_START;
+        }
+        else {
+            return character;
+        }
+    }
+}
+class InQuotedStringInTagState {
+    constructor(mode, quoteCharacter, options) {
+        this.mode = mode;
+        this.quoteCharacter = quoteCharacter;
+        this.options = options;
+    }
+    consume(character, transition) {
+        if (character == this.quoteCharacter) {
+            transition(new InTagState(this.mode, this.options));
+        }
+        if (this.mode == 1 /* TagMode.Disallowed */) {
+            return "";
+        }
+        if (character == TAG_START) {
+            return ENCODED_TAG_START;
+        }
+        else if (character == TAG_END) {
+            return ENCODED_TAG_END;
+        }
+        else {
+            return character;
+        }
+    }
+}
+class InCommentState {
+    constructor(options) {
+        this.options = options;
+        this.consecutiveHyphens = 0;
+    }
+    consume(character, transition) {
+        if (character == ">" && this.consecutiveHyphens >= 2) {
+            transition(new InPlaintextState(this.options));
+        }
+        else if (character == "-") {
+            this.consecutiveHyphens++;
+        }
+        else {
+            this.consecutiveHyphens = 0;
+        }
+        return "";
+    }
+}
+const DefaultStateMachineOptions = {
+    tagReplacementText: "",
+    encodePlaintextTagDelimiters: true,
+};
+class StateMachine {
+    constructor(partialOptions = {}) {
+        this.state = new InPlaintextState({
+            ...DefaultStateMachineOptions,
+            ...partialOptions,
+        });
+        this.transitionFunction = ((next) => {
+            this.state = next;
+        }).bind(this);
+    }
+    consume(text) {
+        let outputBuffer = "";
+        for (const character of text) {
+            outputBuffer += this.state.consume(character, this.transitionFunction);
+        }
+        return outputBuffer;
+    }
+}
+function stripTags(text, options = {}) {
+    return new StateMachine(options).consume(text);
+}
+
 const maskVariable = (value, unmaskedLength = 4) => value
     ? value.substring(0, unmaskedLength).concat(Array.from(value.substring(unmaskedLength))
         .map(() => "*")
@@ -506,6 +700,13 @@ const newUuid = () => {
         return v.toString(16);
     });
 };
+const generateHash = (length) => {
+    let text = "";
+    const possible = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+    for (let i = 0; i < length; i++)
+        text += possible.charAt(Math.floor(Math.random() * possible.length));
+    return text;
+};
 
 function serializeQueryString(obj) {
     let queryString = "";
@@ -31290,9 +31491,13 @@ exports.camelToSnakeCase = camelToSnakeCase;
 exports.createDayPath = createDayPath;
 exports.csvBuild = csvBuild;
 exports.csvParse = csvParse;
+exports.decodeBase64 = decodeBase64;
+exports.decodeUtf8 = decodeUtf8;
 exports.deserializeQueryString = deserializeQueryString;
 exports.distinct = distinct;
 exports.distinctElements = distinctElements;
+exports.encodeBase64 = encodeBase64;
+exports.encodeUtf8 = encodeUtf8;
 exports.ensureDirectory = ensureDirectory;
 exports.ensureStartSlash = ensureStartSlash;
 exports.ensureTailingSlash = ensureTailingSlash;
@@ -31301,6 +31506,7 @@ exports.excelParse = excelParse;
 exports.first = first;
 exports.flatten = flatten;
 exports.floorDateToSecond = floorDateToSecond;
+exports.generateHash = generateHash;
 exports.getDirectoryFilePaths = getDirectoryFilePaths;
 exports.getDirectoryPath = getDirectoryPath;
 exports.getQueryParameter = getQueryParameter;
@@ -31332,6 +31538,7 @@ exports.serializeQueryString = serializeQueryString;
 exports.sleep = sleep;
 exports.sort = sort;
 exports.splitPath = splitPath;
+exports.stripTags = stripTags;
 exports.subArrays = subArrays;
 exports.subtractTime = subtractTime;
 exports.testInternetConnection = testInternetConnection;