@silverbulletmd/silverbullet 2.4.1

package/client/space_lua/stdlib/string.ts

@@ -0,0 +1,286 @@
+import {
+  jsToLuaValue,
+  LuaBuiltinFunction,
+  LuaMultiRes,
+  LuaRuntimeError,
+  LuaTable,
+  luaToString,
+} from "../runtime.ts";
+import { untagNumber } from "../numeric.ts";
+import { luaFormat } from "./format.ts";
+
+// Bits and pieces borrowed from https://github.com/paulcuth/starlight/blob/master/src/runtime/lib/string.js
+
+const ROSETTA_STONE = {
+  "([^a-zA-Z0-9%(])-": "$1*?",
+  "([^%])-([^a-zA-Z0-9?])": "$1*?$2",
+  "([^%])-$": "$1*?",
+  "%a": "[a-zA-Z]",
+  "%A": "[^a-zA-Z]",
+  "%c": "[\x00-\x1f]",
+  "%C": "[^\x00-\x1f]",
+  "%d": "\\d",
+  "%D": "[^\d]",
+  "%l": "[a-z]",
+  "%L": "[^a-z]",
+  "%p": "[\.\,\"'\?\!\;\:\#\$\%\&\(\)\*\+\-\/\<\>\=\@\\[\\]\\\\^\_\{\}\|\~]",
+  "%P": "[^\.\,\"'\?\!\;\:\#\$\%\&\(\)\*\+\-\/\<\>\=\@\\[\\]\\\\^\_\{\}\|\~]",
+  "%s": "[ \\t\\n\\f\\v\\r]",
+  "%S": "[^ \t\n\f\v\r]",
+  "%u": "[A-Z]",
+  "%U": "[^A-Z]",
+  "%w": "[a-zA-Z0-9]",
+  "%W": "[^a-zA-Z0-9]",
+  "%x": "[a-fA-F0-9]",
+  "%X": "[^a-fA-F0-9]",
+  "%([^a-zA-Z])": "\\$1",
+};
+
+function translatePattern(pattern: string): string {
+  pattern = "" + pattern;
+
+  // Replace single backslash with double backslashes
+  pattern = pattern.replace(new RegExp("\\\\", "g"), "\\\\");
+  pattern = pattern.replace(new RegExp("\\|", "g"), "\\|");
+
+  for (const [key, value] of Object.entries(ROSETTA_STONE)) {
+    pattern = pattern.replace(new RegExp(key, "g"), value);
+  }
+
+  let l = pattern.length;
+  let n = 0;
+
+  for (let i = 0; i < l; i++) {
+    const character = pattern.slice(i, 1);
+    if (i && pattern.slice(i - 1, 1) == "\\") {
+      continue;
+    }
+
+    let addSlash = false;
+
+    if (character == "[") {
+      if (n) addSlash = true;
+      n++;
+    } else if (character == "]" && pattern.slice(i - 1, 1) !== "\\") {
+      n--;
+      if (n) addSlash = true;
+    }
+
+    if (addSlash) {
+      pattern = pattern.slice(0, i) + pattern.slice(i++ + 1);
+      l++;
+    }
+  }
+
+  return pattern;
+}
+
+export const stringApi = new LuaTable({
+  byte: new LuaBuiltinFunction((_sf, s: string, i?: number, j?: number) => {
+    i = i ?? 1;
+    j = j ?? i;
+    const result = [];
+    for (let k = i; k <= j; k++) {
+      result.push(s.charCodeAt(k - 1));
+    }
+    return new LuaMultiRes(result);
+  }),
+  char: new LuaBuiltinFunction((_sf, ...args: number[]) => {
+    return String.fromCharCode(...args);
+  }),
+  find: new LuaBuiltinFunction(
+    (_sf, s: string, pattern: string, init = 1, plain = false) => {
+      // Regex
+      if (!plain) {
+        pattern = translatePattern(pattern);
+        const reg = new RegExp(pattern);
+        const index = s.slice(init - 1).search(reg);
+
+        if (index < 0) return null;
+
+        const match = s.slice(init - 1).match(reg);
+        const result = [index + init, index + init + match![0].length - 1];
+
+        match!.shift();
+        return new LuaMultiRes(result.concat(match));
+      }
+
+      // Plain
+      const index = s.indexOf(pattern, init - 1);
+      return (index === -1)
+        ? null
+        : new LuaMultiRes([index + 1, index + pattern.length]);
+    },
+  ),
+  format: new LuaBuiltinFunction((_sf, format: string, ...args: any[]) => {
+    // Unwrap tagged floats so luaFormat sees plain numbers
+    for (let i = 0; i < args.length; i++) {
+      args[i] = untagNumber(args[i]);
+    }
+    return luaFormat(format, ...args);
+  }),
+  gmatch: new LuaBuiltinFunction((_sf, s: string, pattern: string) => {
+    pattern = translatePattern(pattern);
+    const reg = new RegExp(pattern, "g"),
+      matches = s.match(reg);
+    return () => {
+      if (!matches) {
+        return;
+      }
+      const match = matches.shift();
+      if (!match) {
+        return;
+      }
+      const groups = new RegExp(pattern).exec(match) || [];
+
+      groups.shift();
+      return groups.length ? new LuaMultiRes(groups) : match;
+    };
+  }),
+  gsub: new LuaBuiltinFunction(
+    async (
+      sf,
+      s: string,
+      pattern: string,
+      repl: any, // string or LuaFunction
+      n = Infinity,
+    ) => {
+      pattern = translatePattern(pattern);
+      const replIsFunction = repl.call;
+
+      let count = 0,
+        result = "",
+        str,
+        prefix,
+        match: any,
+        lastMatch;
+
+      while (
+        count < n &&
+        s &&
+        (match = s.match(pattern))
+      ) {
+        if (replIsFunction) {
+          // If no captures, pass in the whole match
+          if (match[1] === undefined) {
+            str = await repl.call(sf, match[0]);
+          } else {
+            // Else pass in the captures
+            str = await repl.call(sf, ...match.slice(1));
+          }
+          if (str instanceof LuaMultiRes) {
+            str = str.values[0];
+          }
+          if (str === undefined || str === null) {
+            str = match[0];
+          }
+        } else if (repl instanceof LuaTable) {
+          str = repl.get(match[0]);
+        } else if (typeof repl === "string") {
+          str = repl.replaceAll(/%([0-9]+)/g, (_, i) => match[i]);
+        } else {
+          throw new LuaRuntimeError(
+            "string.gsub replacement argument should be a function, table or string",
+            sf,
+          );
+        }
+
+        if (match[0].length === 0) {
+          if (lastMatch === void 0) {
+            prefix = "";
+          } else {
+            prefix = s.slice(0, 1);
+          }
+        } else {
+          prefix = s.slice(0, match.index);
+        }
+
+        lastMatch = match[0];
+        result += `${prefix}${str}`;
+        s = s.slice(`${prefix}${lastMatch}`.length);
+
+        count++;
+      }
+
+      return new LuaMultiRes([`${result}${s}`, count]);
+    },
+  ),
+  len: new LuaBuiltinFunction((_sf, s: string) => {
+    return s.length;
+  }),
+  lower: new LuaBuiltinFunction((_sf, s: string) => {
+    return luaToString(s.toLowerCase());
+  }),
+  upper: new LuaBuiltinFunction((_sf, s: string) => {
+    return luaToString(s.toUpperCase());
+  }),
+  match: new LuaBuiltinFunction(
+    (_sf, s: string, pattern: string, init = 1) => {
+      s = s.slice(init - 1);
+      const matches = s.match(new RegExp(translatePattern(pattern)));
+
+      if (!matches) {
+        return null;
+      }
+      if (matches[1] === undefined) {
+        // No captures
+        return matches[0];
+      }
+
+      matches.shift();
+      return new LuaMultiRes(matches);
+    },
+  ),
+  rep: new LuaBuiltinFunction((_sf, s: string, n: number, sep?: string) => {
+    sep = sep ?? "";
+    return s.repeat(n) + sep;
+  }),
+  reverse: new LuaBuiltinFunction((_sf, s: string) => {
+    return s.split("").reverse().join("");
+  }),
+  sub: new LuaBuiltinFunction((_sf, s: string, i: number, j?: number) => {
+    j = j ?? s.length;
+    if (i < 0) {
+      i = s.length + i + 1;
+    }
+    if (j < 0) {
+      j = s.length + j + 1;
+    }
+    return s.slice(i - 1, j);
+  }),
+  split: new LuaBuiltinFunction((_sf, s: string, sep: string) => {
+    return s.split(sep);
+  }),
+
+  // Non-standard
+  startsWith: new LuaBuiltinFunction((_sf, s: string, prefix: string) => {
+    return s.startsWith(prefix);
+  }),
+  endsWith: new LuaBuiltinFunction((_sf, s: string, suffix: string) => {
+    return s.endsWith(suffix);
+  }),
+  trim: new LuaBuiltinFunction((_sf, s: string) => {
+    return s.trim();
+  }),
+  trimStart: new LuaBuiltinFunction((_sf, s: string) => {
+    return s.trimStart();
+  }),
+  trimEnd: new LuaBuiltinFunction((_sf, s: string) => {
+    return s.trimEnd();
+  }),
+  matchRegex: new LuaBuiltinFunction((_sf, s: string, pattern: string) => {
+    const regex = new RegExp(pattern);
+    const result = s.match(regex);
+    return jsToLuaValue(result);
+  }),
+  matchRegexAll: new LuaBuiltinFunction((_sf, s: string, pattern: string) => {
+    const regex = new RegExp(pattern, "g");
+    return () => {
+      const match = regex.exec(s);
+      if (!match) {
+        return;
+      }
+      return jsToLuaValue(match);
+    };
+  }),
+});

package/client/space_lua/stdlib/table.ts

@@ -0,0 +1,401 @@
+import {
+  getMetatable,
+  type ILuaFunction,
+  LuaBuiltinFunction,
+  luaCall,
+  type LuaEnv,
+  luaEquals,
+  luaGet,
+  LuaMultiRes,
+  LuaRuntimeError,
+  luaSet,
+  LuaTable,
+  type LuaValue,
+  luaValueToJS,
+  singleResult,
+} from "../runtime.ts";
+import { asyncQuickSort, evalPromiseValues } from "../util.ts";
+import { isTaggedFloat } from "../numeric.ts";
+
+// For `LuaTable` honor `__len` when present; otherwise use raw array
+// length.  For JS arrays use `.length`.
+function luaLenForTableLib(
+  sf: any,
+  tbl: LuaTable | any[],
+): number | Promise<number> {
+  if (Array.isArray(tbl)) {
+    return tbl.length;
+  }
+  if (!(tbl instanceof LuaTable)) {
+    return 0;
+  }
+
+  const mt = getMetatable(tbl, sf);
+  const mm = mt ? mt.rawGet("__len") : null;
+  if (!(mm === undefined || mm === null)) {
+    const r = luaCall(mm, [tbl], sf.astCtx ?? {}, sf);
+    if (r instanceof Promise) {
+      return r.then((v: any) => Number(singleResult(v)));
+    }
+    return Number(singleResult(r));
+  }
+
+  return tbl.length;
+}
+
+async function luaLenForTableLibAsync(sf: any, tbl: LuaTable | any[]) {
+  const r = luaLenForTableLib(sf, tbl);
+  return r instanceof Promise ? await r : r;
+}
+
+export const tableApi = new LuaTable({
+  /**
+   * Concatenates the elements of a table into a string, using a separator.
+   * @param tbl - The table to concatenate.
+   * @param sep - The separator to use between elements.
+   * @param i - The start index.
+   * @param j - The end index.
+   * @returns The concatenated string.
+   */
+  concat: new LuaBuiltinFunction(
+    async (sf, tbl: LuaTable | any[], sep?: string, i?: number, j?: number) => {
+      sep = sep ?? "";
+      i = i ?? 1;
+      if (j === undefined || j === null) {
+        j = await luaLenForTableLibAsync(sf, tbl);
+      }
+
+      const luaConcatElemToString = (v: any, idx: number): string => {
+        // Concat errors on nil and non-string or non-number values.
+        if (v === null || v === undefined) {
+          throw new LuaRuntimeError(
+            `invalid value (nil) at index ${idx} in table for 'concat'`,
+            sf,
+          );
+        }
+        if (typeof v === "string") {
+          return v;
+        }
+        if (typeof v === "number") {
+          return String(v);
+        }
+        if (isTaggedFloat(v)) {
+          return String(v.value);
+        }
+
+        const ty = typeof v === "object" && v instanceof LuaTable
+          ? "table"
+          : typeof v;
+        throw new LuaRuntimeError(
+          `invalid value (${ty}) at index ${idx} in table for 'concat'`,
+          sf,
+        );
+      };
+
+      if (Array.isArray(tbl)) {
+        const out: string[] = [];
+        for (let k = i; k <= j; k++) {
+          const v = tbl[k - 1];
+          out.push(luaConcatElemToString(v, k));
+        }
+        return out.join(sep);
+      }
+
+      const out: string[] = [];
+      for (let k = i; k <= j; k++) {
+        const v = await luaGet(tbl, k, sf.astCtx ?? null, sf);
+        out.push(luaConcatElemToString(v, k));
+      }
+      return out.join(sep);
+    },
+  ),
+
+  /**
+   * Inserts an element into a table at a specified position.
+   * @param tbl - The table to insert the element into.
+   * @param posOrValue - The position or value to insert.
+   * @param value - The value to insert.
+   */
+  insert: new LuaBuiltinFunction(
+    async (
+      sf,
+      tbl: LuaTable | any[],
+      posOrValue: number | any,
+      value?: any,
+    ) => {
+      if (Array.isArray(tbl)) {
+        // Since we're inserting/appending to a native JS array, we'll also convert the value to a JS value on the fly
+        // this seems like a reasonable heuristic
+        if (value === undefined) {
+          tbl.push(luaValueToJS(posOrValue, sf));
+        } else {
+          tbl.splice(posOrValue - 1, 0, luaValueToJS(value, sf));
+        }
+        return;
+      }
+
+      if (!(tbl instanceof LuaTable)) {
+        return;
+      }
+
+      let pos: number;
+      let v: any;
+
+      if (value === undefined) {
+        v = posOrValue;
+        pos = (await luaLenForTableLibAsync(sf, tbl)) + 1;
+      } else {
+        pos = posOrValue;
+        v = value;
+      }
+
+      const n = await luaLenForTableLibAsync(sf, tbl);
+
+      // Shift up: for k = n, pos, -1 do t[k+1] = t[k] end
+      for (let k = n; k >= pos; k--) {
+        const cur = await luaGet(tbl, k, sf.astCtx ?? null, sf);
+        await luaSet(tbl, k + 1, cur, sf);
+      }
+
+      await luaSet(tbl, pos, v, sf);
+    },
+  ),
+
+  /**
+   * Removes an element from a table at a specified position.
+   * @param tbl - The table to remove the element from.
+   * @param pos - The position of the element to remove.
+   */
+  remove: new LuaBuiltinFunction(
+    async (sf, tbl: LuaTable | any[], pos?: number) => {
+      if (Array.isArray(tbl)) {
+        const n = tbl.length;
+        const p = pos ?? n;
+        if (p < 1 || p > n) {
+          throw new LuaRuntimeError("position out of bounds", sf);
+        }
+        const idx = p - 1;
+        const v = tbl[idx];
+        tbl.splice(idx, 1);
+        return v;
+      }
+
+      if (!(tbl instanceof LuaTable)) {
+        return null;
+      }
+
+      const n = await luaLenForTableLibAsync(sf, tbl);
+      const p = pos ?? n;
+
+      if (p < 1 || p > n) {
+        throw new LuaRuntimeError("position out of bounds", sf);
+      }
+
+      const v = await luaGet(tbl, p, sf.astCtx ?? null, sf);
+
+      // Shift down: for k = p, n-1 do t[k] = t[k+1] end; t[n] = nil
+      for (let k = p; k < n; k++) {
+        const next = await luaGet(tbl, k + 1, sf.astCtx ?? null, sf);
+        await luaSet(tbl, k, next, sf);
+      }
+      await luaSet(tbl, n, null, sf);
+
+      return v;
+    },
+  ),
+
+  /**
+   * Sorts a table.
+   * @param tbl - The table to sort.
+   * @param comp - The comparison function.
+   * @returns The sorted table.
+   */
+  sort: new LuaBuiltinFunction(
+    async (sf, tbl: LuaTable | any[], comp?: ILuaFunction) => {
+      if (Array.isArray(tbl)) {
+        return await asyncQuickSort(tbl, async (a, b) => {
+          if (comp) {
+            return (await comp.call(sf, a, b)) ? -1 : 1;
+          }
+          return (a as any) < (b as any) ? -1 : 1;
+        });
+      }
+
+      if (!(tbl instanceof LuaTable)) {
+        return tbl;
+      }
+
+      const n = await luaLenForTableLibAsync(sf, tbl);
+
+      const values: any[] = [];
+      for (let i = 1; i <= n; i++) {
+        values.push(await luaGet(tbl, i, sf.astCtx ?? null, sf));
+      }
+
+      const cmp = async (a: any, b: any): Promise<number> => {
+        if (comp) {
+          const r = await luaCall(comp, [a, b], sf.astCtx ?? {}, sf);
+          return r ? -1 : 1;
+        }
+
+        const av = isTaggedFloat(a) ? a.value : a;
+        const bv = isTaggedFloat(b) ? b.value : b;
+
+        if (typeof av === "number" && typeof bv === "number") {
+          return av < bv ? -1 : 1;
+        }
+        if (typeof av === "string" && typeof bv === "string") {
+          return av < bv ? -1 : 1;
+        }
+
+        const ta = typeof av;
+        const tb = typeof bv;
+        throw new LuaRuntimeError(
+          `attempt to compare ${ta} with ${tb}`,
+          sf,
+        );
+      };
+
+      const sorted = await asyncQuickSort(values, cmp);
+
+      for (let i = 1; i <= n; i++) {
+        await luaSet(tbl, i, sorted[i - 1], sf);
+      }
+
+      return tbl;
+    },
+  ),
+
+  /**
+   * Returns the keys of a table.
+   * Note: Space Lua specific
+   * @param tbl - The table to get the keys from.
+   * @returns The keys of the table.
+   */
+  keys: new LuaBuiltinFunction((_sf, tbl: LuaTable | LuaEnv | any) => {
+    if (tbl.keys) {
+      return tbl.keys();
+    }
+    return Object.keys(tbl);
+  }),
+
+  /**
+   * Checks if a table (used as an array) contains a value.
+   * Note: Space Lua specific
+   * @param tbl - The table to check.
+   * @param value - The value to check for.
+   * @returns True if the value is in the table, false otherwise.
+   */
+  includes: new LuaBuiltinFunction(
+    (sf, tbl: LuaTable | any[], value: LuaValue) => {
+      if (!tbl) {
+        return false;
+      }
+      if (tbl instanceof LuaTable) {
+        // Iterate over the table
+        for (const key of tbl.keys()) {
+          if (luaEquals(tbl.get(key), value)) {
+            return true;
+          }
+        }
+        return false;
+      }
+      if (Array.isArray(tbl)) {
+        return !!tbl.find((item) => luaEquals(item, value));
+      }
+      throw new LuaRuntimeError(
+        `Cannot use includes on a non-table or non-array value`,
+        sf,
+      );
+    },
+  ),
+
+  /**
+   * Returns a new table from an old one, only with selected keys
+   * @param tbl a Lua table or JS object
+   * @param keys a list of keys to select from the table, if keys[0] is a table or array, assumed to contain the keys to select
+   * @returns a new table with only the selected keys
+   */
+  select: new LuaBuiltinFunction(
+    (sf, tbl: LuaTable | Record<string, any>, ...keys: LuaValue[]) => {
+      // Normalize arguments
+      if (Array.isArray(keys[0])) {
+        // First argument is key array, let's unpack
+        keys = keys[0];
+      } else if (keys[0] instanceof LuaTable) {
+        keys = keys[0].toJSArray();
+      }
+      const resultTable = new LuaTable();
+      const setPromises: (void | Promise<void>)[] = [];
+      for (const key of keys) {
+        setPromises.push(resultTable.set(key, luaGet(tbl, key, null, sf)));
+      }
+      const promised = evalPromiseValues(setPromises);
+      if (promised instanceof Promise) {
+        return promised.then(() => resultTable);
+      }
+      return resultTable;
+    },
+  ),
+
+  pack: new LuaBuiltinFunction((_sf, ...args: any[]) => {
+    const tbl = new LuaTable();
+    for (let i = 0; i < args.length; i++) {
+      tbl.set(i + 1, args[i]);
+    }
+    tbl.set("n", args.length);
+    return tbl;
+  }),
+
+  unpack: new LuaBuiltinFunction(
+    async (sf, tbl: LuaTable | any[], i?: number, j?: number) => {
+      i = i ?? 1;
+      if (j === undefined || j === null) {
+        j = Array.isArray(tbl)
+          ? tbl.length
+          : await luaLenForTableLibAsync(sf, tbl);
+      }
+
+      const result: LuaValue[] = [];
+      for (let k = i; k <= j; k++) {
+        const v = Array.isArray(tbl)
+          ? tbl[k - 1]
+          : await luaGet(tbl, k, sf.astCtx ?? null, sf);
+        result.push(v);
+      }
+      return new LuaMultiRes(result);
+    },
+  ),
+
+  // Non-standard Lua functions
+  /**
+   * Finds an element in a table that matches a criteria function. Returns the first matching element.
+   * @param tbl - The table to search.
+   * @param criteriaFn - The criteria function.
+   * @param fromIndex - The index to start searching from.
+   * @returns Lua multi value of index, value, or nil if no element is found.
+   */
+  find: new LuaBuiltinFunction(
+    async (
+      sf,
+      tbl: LuaTable | any[],
+      criteriaFn: ILuaFunction,
+      fromIndex = 1,
+    ) => {
+      if (!tbl) {
+        return null;
+      }
+      const startIndex = fromIndex < 1 ? 1 : fromIndex;
+      const n = Array.isArray(tbl)
+        ? tbl.length
+        : await luaLenForTableLibAsync(sf, tbl);
+      for (let i = startIndex; i <= n; i++) {
+        const val = await luaGet(tbl, i, sf.astCtx ?? null, sf);
+        if (await luaCall(criteriaFn, [val], sf.astCtx!, sf)) {
+          return new LuaMultiRes([i, val]);
+        }
+      }
+      return null;
+    },
+  ),
+});