@visulima/string 1.0.0

package/dist/outdent.mjs

@@ -0,0 +1,118 @@
+import { b as RE_ONLY_WHITESPACE_WITH_AT_LEAST_ONE_NEWLINE, c as RE_STARTS_WITH_NEWLINE_OR_IS_EMPTY, d as RE_LEADING_NEWLINE, e as RE_TRAILING_NEWLINE, f as RE_MATCH_NEWLINES, g as RE_DETECT_INDENTATION } from './packem_shared/constants-BnVGLrDr.mjs';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const hop = Object.prototype.hasOwnProperty;
+const has = /* @__PURE__ */ __name((object, property) => hop.call(object, property), "has");
+const extend = /* @__PURE__ */ __name((target, source) => {
+  for (const property in source) {
+    if (has(source, property)) {
+      target[property] = source[property];
+    }
+  }
+  return target;
+}, "extend");
+const internalOutdentArray = /* @__PURE__ */ __name((strings, firstInterpolatedValueSetsIndentationLevel, options) => {
+  if (strings.length === 0) {
+    return [];
+  }
+  let indentationLevel = 0;
+  const match = RE_DETECT_INDENTATION.exec(strings[0]);
+  if (match) {
+    indentationLevel = match[1].length;
+  }
+  const reSource = `(\\r\\n|\\r|\\n).{0,${indentationLevel}}`;
+  const reMatchIndent = new RegExp(reSource, "g");
+  if (firstInterpolatedValueSetsIndentationLevel) {
+    strings = strings.slice(1);
+  }
+  const { newline, trimLeadingNewline, trimTrailingNewline } = options;
+  const normalizeNewlines = typeof newline === "string";
+  const l = strings.length;
+  const outdentedStrings = Array.from({ length: l });
+  for (let index = 0; index < l; index++) {
+    let v = strings[index];
+    v = v.replace(reMatchIndent, "$1");
+    if (index === 0 && trimLeadingNewline) {
+      v = v.replace(RE_LEADING_NEWLINE, "");
+    }
+    if (index === l - 1 && trimTrailingNewline) {
+      v = v.replace(RE_TRAILING_NEWLINE, "");
+    }
+    if (normalizeNewlines) {
+      v = v.replaceAll(RE_MATCH_NEWLINES, newline);
+    }
+    outdentedStrings[index] = v;
+  }
+  return outdentedStrings;
+}, "internalOutdentArray");
+const concatStringsAndValues = /* @__PURE__ */ __name((strings, values) => {
+  const chunks = Array.from({ length: strings.length + values.length });
+  let index = 0;
+  const l = strings.length;
+  for (; index < l - 1; index++) {
+    chunks[index * 2] = strings[index];
+    chunks[index * 2 + 1] = String(values[index]);
+  }
+  chunks[index * 2] = strings[index];
+  return chunks.join("");
+}, "concatStringsAndValues");
+const isTemplateStringsArray = /* @__PURE__ */ __name((v) => has(v, "raw") && has(v, "length"), "isTemplateStringsArray");
+const templateCache = /* @__PURE__ */ new WeakMap();
+const createInstance = /* @__PURE__ */ __name((options) => {
+  const enableCache = options.cache !== false;
+  const cache = enableCache ? options.cacheStore ?? templateCache : null;
+  const hasNewlineOption = options.newline !== void 0;
+  function outdent2(stringsOrOptions, ...values) {
+    if (isTemplateStringsArray(stringsOrOptions)) {
+      const strings = stringsOrOptions;
+      const valuesLength = values.length;
+      if (strings.length === 1 && strings[0] === "") {
+        return "";
+      }
+      if (valuesLength === 0) {
+        if (enableCache && cache && !hasNewlineOption) {
+          const cached = cache.get(strings);
+          if (cached) {
+            return cached[0];
+          }
+        }
+        const result = internalOutdentArray(strings, false, options);
+        if (enableCache && cache) {
+          cache.set(strings, result);
+        }
+        return result[0];
+      }
+      const firstValueIsOutdent = values[0] === outdent2 || values[0] === defaultOutdent;
+      const firstInterpolatedValueSetsIndentationLevel = firstValueIsOutdent && RE_ONLY_WHITESPACE_WITH_AT_LEAST_ONE_NEWLINE.test(strings[0]) && RE_STARTS_WITH_NEWLINE_OR_IS_EMPTY.test(strings[1]);
+      let renderedArray;
+      if (enableCache && cache && !hasNewlineOption) {
+        renderedArray = cache.get(strings);
+      }
+      if (!renderedArray) {
+        renderedArray = internalOutdentArray(strings, firstInterpolatedValueSetsIndentationLevel, options);
+        if (enableCache && cache) {
+          cache.set(strings, renderedArray);
+        }
+      }
+      return concatStringsAndValues(renderedArray, firstInterpolatedValueSetsIndentationLevel ? values.slice(1) : values);
+    }
+    return createInstance(extend(extend({}, options), stringsOrOptions));
+  }
+  __name(outdent2, "outdent");
+  return extend(outdent2, {
+    string(string_) {
+      if (string_ === "" || !string_) {
+        return "";
+      }
+      return internalOutdentArray([string_], false, options)[0];
+    }
+  });
+}, "createInstance");
+const defaultOutdent = createInstance({
+  trimLeadingNewline: true,
+  trimTrailingNewline: true
+});
+const outdent = defaultOutdent;
+
+export { outdent };

package/dist/packem_shared/LRUCache-Crb-m7cw.cjs

@@ -0,0 +1,53 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class LRUCache {
+  static {
+    __name(this, "LRUCache");
+  }
+  capacity;
+  cache;
+  keyOrder;
+  constructor(capacity) {
+    this.capacity = capacity;
+    this.cache = /* @__PURE__ */ new Map();
+    this.keyOrder = [];
+  }
+  get(key) {
+    if (!this.cache.has(key)) {
+      return void 0;
+    }
+    this.keyOrder = this.keyOrder.filter((k) => k !== key);
+    this.keyOrder.push(key);
+    return this.cache.get(key);
+  }
+  has(key) {
+    return this.cache.has(key);
+  }
+  set(key, value) {
+    if (this.cache.has(key)) {
+      this.keyOrder = this.keyOrder.filter((k) => k !== key);
+    } else if (this.cache.size >= this.capacity) {
+      const lruKey = this.keyOrder.shift();
+      if (lruKey !== void 0) {
+        this.cache.delete(lruKey);
+      }
+    }
+    this.cache.set(key, value);
+    this.keyOrder.push(key);
+  }
+  delete(key) {
+    this.cache.delete(key);
+    this.keyOrder = this.keyOrder.filter((k) => k !== key);
+  }
+  clear() {
+    this.cache.clear();
+    this.keyOrder = [];
+  }
+  size() {
+    return this.cache.size;
+  }
+}
+
+module.exports = LRUCache;

package/dist/packem_shared/LRUCache-udNErhWw.mjs

@@ -0,0 +1,51 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class LRUCache {
+  static {
+    __name(this, "LRUCache");
+  }
+  capacity;
+  cache;
+  keyOrder;
+  constructor(capacity) {
+    this.capacity = capacity;
+    this.cache = /* @__PURE__ */ new Map();
+    this.keyOrder = [];
+  }
+  get(key) {
+    if (!this.cache.has(key)) {
+      return void 0;
+    }
+    this.keyOrder = this.keyOrder.filter((k) => k !== key);
+    this.keyOrder.push(key);
+    return this.cache.get(key);
+  }
+  has(key) {
+    return this.cache.has(key);
+  }
+  set(key, value) {
+    if (this.cache.has(key)) {
+      this.keyOrder = this.keyOrder.filter((k) => k !== key);
+    } else if (this.cache.size >= this.capacity) {
+      const lruKey = this.keyOrder.shift();
+      if (lruKey !== void 0) {
+        this.cache.delete(lruKey);
+      }
+    }
+    this.cache.set(key, value);
+    this.keyOrder.push(key);
+  }
+  delete(key) {
+    this.cache.delete(key);
+    this.keyOrder = this.keyOrder.filter((k) => k !== key);
+  }
+  clear() {
+    this.cache.clear();
+    this.keyOrder = [];
+  }
+  size() {
+    return this.cache.size;
+  }
+}
+
+export { LRUCache as default };