seroval 0.1.0

package/LICENSE

@@ -0,0 +1,7 @@
+MIT License Copyright (c) 2023 <author>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice (including the next paragraph) shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,153 @@
+# seroval
+
+> Stringify JS values
+
+[![NPM](https://img.shields.io/npm/v/seroval.svg)](https://www.npmjs.com/package/seroval) [![JavaScript Style Guide](https://badgen.net/badge/code%20style/airbnb/ff5a5f?icon=airbnb)](https://github.com/airbnb/javascript)
+
+## Install
+
+```bash
+npm install --save seroval
+```
+
+```bash
+yarn add seroval
+```
+
+```bash
+pnpm add seroval
+```
+
+## Usage
+
+```js
+import seroval from 'seroval';
+
+const object = {
+  number: [Math.random(), -0, NaN, Infinity, -Infinity],
+  string: ['hello world', '<script>Hello World</script>'],
+  boolean: [true, false],
+  null: null,
+  undefined: undefined,
+  bigint: 9007199254740991n,
+  array: [,,,], // holes
+  regexp: /[a-z0-9]+/i,
+  date: new Date(),
+  map: new Map([['hello', 'world']]),
+  set: new Set(['hello', 'world']),
+};
+
+// self cyclic references
+// recursive objects
+object.self = object;
+// recursive arrays
+object.array.push(object.array);
+// recursive maps
+object.map.set('self', object.map);
+// recursive sets
+object.set.add(object.set);
+
+// mutual cyclic references
+object.array.push(object.map);
+object.map.set('mutual', object.set);
+object.set.add(object.array);
+
+const result = seroval(object);
+```
+
+Output (as a string):
+
+```js
+((h,j,k,m)=>(h={number:[0.5906513825027921,-0,NaN,Infinity,-Infinity],string:["hello world","\x3Cscript>Hello World\x3C/script>"],boolean:[!0,!1],null:null,undefined:void 0,bigint:BigInt("9007199254740991"),array:j=[,,,,k=new Map([["hello","world"],["mutual",m=new Set(["hello","world"])]])],regexp:/[a-z0-9]+/i,date:new Date("2023-02-06T06:16:00.384Z"),map:k,set:m},j[3]=j,h.self=h,k.set("self",k),m.add(m).add(j),h))()
+
+// Formatted for readability
+((h, j, k, m) => (h = {
+  number: [0.5906513825027921, -0, NaN, Infinity, -Infinity],
+  string: ["hello world", "\x3Cscript>Hello World\x3C/script>"],
+  boolean: [!0, !1],
+  null: null,
+  undefined: void 0,
+  bigint: BigInt("9007199254740991"),
+  array: j = [, , , , k = new Map([
+    ["hello", "world"],
+    ["mutual", m = new Set(["hello", "world"])]
+  ])],
+  regexp: /[a-z0-9]+/i,
+  date: new Date("2023-02-06T06:16:00.384Z"),
+  map: k,
+  set: m
+}, j[3] = j, h.self = h, k.set("self", k), m.add(m).add(j), h))()
+```
+
+### Mutual cyclic example
+
+```js
+import seroval from 'seroval';
+
+const a = new Map([['name', 'a']]);
+const b = new Map([['name', 'b']]);
+const c = new Map([['name', 'c']]);
+const d = new Map([['name', 'd']]);
+
+c.set('left', a);
+d.set('left', a);
+c.set('right', b);
+d.set('right', b);
+a.set('children', [c, d]);
+b.set('children', [c, d]);
+
+const result = seroval({ a, b, c, d });
+```
+
+Output (as a string):
+
+```js
+((h,j,k,m,o,q)=>(q={a:h=new Map([["name","a"],["children",[j=new Map([["name","c"],["right",k=new Map([["name","b"],["children",o=[,m=new Map([["name","d"]])]]])]]),m]]]),b:k,c:j,d:m},o[0]=j,j.set("left",h),m.set("left",h).set("right",k),q))()
+
+// Formatted
+((h, j, k, m, o, q) => (q = {
+  a: h = new Map([
+    ["name", "a"],
+    ["children", [j = new Map([
+      ["name", "c"],
+      ["right", k = new Map([
+        ["name", "b"],
+        ["children", o = [, m = new Map([
+          ["name", "d"]
+        ])]]
+      ])]
+    ]), m]]
+  ]),
+  b: k,
+  c: j,
+  d: m
+}, o[0] = j, j.set("left", h), m.set("left", h).set("right", k), q))()
+```
+
+## Supports
+
+The following values are the only values accepted by `seroval`:
+
+- Exact values
+  - `NaN`
+  - `Infinity`
+  - `-Infinity`
+  - `-0`
+- Primitives
+  - `number`
+  - `string`
+  - `boolean`
+  - `null`
+  - `undefined`
+  - `bigint`
+- `Array` + holes
+- `Object`
+  - `RegExp`
+  - `Date`
+  - `Map`
+  - `Set`
+- Cyclic references (both self and mutual)
+
+## License
+
+MIT © [lxsmnsyc](https://github.com/lxsmnsyc)

package/dist/cjs/development/index.cjs

@@ -0,0 +1,481 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  default: () => serialize
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/array.ts
+function forEach(arr, callback) {
+  for (let i = 0, len = arr.length; i < len; i++) {
+    if (callback(arr[i], i)) {
+      break;
+    }
+  }
+}
+function join(arr, joiner) {
+  let result = "";
+  forEach(arr, (value, index) => {
+    result += value;
+    if (index < arr.length - 1) {
+      result += joiner;
+    }
+  });
+  return result;
+}
+
+// src/get-identifier.ts
+var REF_START_CHARS = "hjkmoquxzABCDEFGHIJKLNPQRTUVWXYZ$_";
+var REF_START_CHARS_LEN = REF_START_CHARS.length;
+var REF_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789$_";
+var REF_CHARS_LEN = REF_CHARS.length;
+function getIdentifier(index) {
+  let mod = index % REF_START_CHARS_LEN;
+  let ref = REF_START_CHARS[mod];
+  index = (index - mod) / REF_START_CHARS_LEN;
+  while (index > 0) {
+    mod = index % REF_CHARS_LEN;
+    ref += REF_CHARS[mod];
+    index = (index - mod) / REF_CHARS_LEN;
+  }
+  return ref;
+}
+
+// src/quote.ts
+function quote(str) {
+  let result = "";
+  let lastPos = 0;
+  for (let i = 0, len = str.length; i < len; i++) {
+    let replacement;
+    switch (str[i]) {
+      case '"':
+        replacement = '\\"';
+        break;
+      case "\\":
+        replacement = "\\\\";
+        break;
+      case "<":
+        replacement = "\\x3C";
+        break;
+      case "\n":
+        replacement = "\\n";
+        break;
+      case "\r":
+        replacement = "\\r";
+        break;
+      case "\u2028":
+        replacement = "\\u2028";
+        break;
+      case "\u2029":
+        replacement = "\\u2029";
+        break;
+      default:
+        continue;
+    }
+    result += str.slice(lastPos, i) + replacement;
+    lastPos = i + 1;
+  }
+  if (lastPos === 0) {
+    result = str;
+  } else {
+    result += str.slice(lastPos);
+  }
+  return `"${result}"`;
+}
+
+// src/index.ts
+var EMPTY_SET = "new Set";
+var EMPTY_MAP = "new Map";
+var EMPTY_ARRAY = "[]";
+var REF_COUNT = /* @__PURE__ */ new Map();
+var STACK = /* @__PURE__ */ new Set();
+var REFS = /* @__PURE__ */ new Map();
+var ASSIGNED_REFS = /* @__PURE__ */ new Set();
+var VARS = [];
+var ASSIGNMENTS = [];
+var MAP_SETS = [];
+var SET_ADDS = [];
+function reset() {
+  ASSIGNMENTS = [];
+  MAP_SETS = [];
+  SET_ADDS = [];
+  VARS = [];
+  REF_COUNT.clear();
+  REFS.clear();
+  ASSIGNED_REFS.clear();
+}
+function resolveAssignments() {
+  if (ASSIGNMENTS.length) {
+    const result = {};
+    forEach(ASSIGNMENTS, ([source, value]) => {
+      if (value in result) {
+        result[value] = `${source}=${result[value]}`;
+      } else {
+        result[value] = `${source}=${value}`;
+      }
+    });
+    return `${join(Object.values(result), ",")},`;
+  }
+  return "";
+}
+function resolveMapSets() {
+  if (MAP_SETS.length) {
+    const result = {};
+    forEach(MAP_SETS, ([source, key, value]) => {
+      if (source in result) {
+        result[source] = `${result[source]}.set(${key},${value})`;
+      } else {
+        result[source] = `${source}.set(${key},${value})`;
+      }
+    });
+    return `${join(Object.values(result), ",")},`;
+  }
+  return "";
+}
+function resolveSetAdds() {
+  if (SET_ADDS.length) {
+    const result = {};
+    forEach(SET_ADDS, ([source, value]) => {
+      if (source in result) {
+        result[source] = `${result[source]}.add(${value})`;
+      } else {
+        result[source] = `${source}.add(${value})`;
+      }
+    });
+    return `${join(Object.values(result), ",")},`;
+  }
+  return "";
+}
+function resolvePatches() {
+  return `${resolveAssignments()}${resolveMapSets()}${resolveSetAdds()}`;
+}
+function insertRef(current) {
+  const count = REF_COUNT.get(current) || 0;
+  REF_COUNT.set(current, count + 1);
+  return count === 0;
+}
+function constructorCheck(value, constructor) {
+  return value.constructor === constructor;
+}
+function isPrimitive(current) {
+  if (!current || current === true) {
+    return true;
+  }
+  const type = typeof current;
+  const classConst = current.constructor;
+  return type === "number" || type === "string" || type === "bigint" || classConst === Date || classConst === RegExp;
+}
+function lookupRefs(current) {
+  if (isPrimitive(current)) {
+    return;
+  }
+  if (Array.isArray(current)) {
+    if (insertRef(current)) {
+      forEach(current, lookupRefs);
+    }
+  } else if (constructorCheck(current, Set)) {
+    if (insertRef(current)) {
+      for (const item of current.keys()) {
+        lookupRefs(item);
+      }
+    }
+  } else if (constructorCheck(current, Map)) {
+    if (insertRef(current)) {
+      for (const [key, value] of current.entries()) {
+        lookupRefs(key);
+        lookupRefs(value);
+      }
+    }
+  } else if (current.constructor === Object && insertRef(current)) {
+    forEach(Object.values(current), lookupRefs);
+  }
+}
+function createRef(value) {
+  const current = REFS.get(value);
+  if (current != null) {
+    return current;
+  }
+  const id = REFS.size;
+  REFS.set(value, id);
+  return id;
+}
+function getRefParam(index) {
+  if (VARS[index]) {
+    return VARS[index];
+  }
+  const result = getIdentifier(index);
+  VARS[index] = result;
+  return result;
+}
+function assignRef(index, value) {
+  return `${getRefParam(index)}=${value}`;
+}
+function createAssignment(source, value) {
+  ASSIGNMENTS.push([source, value]);
+}
+function createSetAdd(ref, value) {
+  SET_ADDS.push([getRefParam(ref), value]);
+}
+function createMapSet(ref, key, value) {
+  MAP_SETS.push([getRefParam(ref), key, value]);
+}
+function createArrayAssign(ref, index, value) {
+  createAssignment(`${getRefParam(ref)}[${index}]`, value);
+}
+function createObjectIdentifierAssign(ref, key, value) {
+  createAssignment(`${getRefParam(ref)}.${key}`, value);
+}
+function createObjectStringAssign(ref, key, value) {
+  createAssignment(`${getRefParam(ref)}[${quote(key)}]`, value);
+}
+function serializePrimitive(value) {
+  if (value === true) {
+    return "!0";
+  }
+  if (value === false) {
+    return "!1";
+  }
+  if (value === void 0) {
+    return "void 0";
+  }
+  if (value === null) {
+    return "null";
+  }
+  if (Object.is(value, -0)) {
+    return "-0";
+  }
+  if (typeof value === "bigint") {
+    return `BigInt("${value}")`;
+  }
+  if (typeof value === "string") {
+    return quote(value);
+  }
+  if (value.constructor === Date) {
+    return `new Date("${value.toISOString()}")`;
+  }
+  return String(value);
+}
+function traverse(current) {
+  if (isPrimitive(current)) {
+    return serializePrimitive(current);
+  }
+  let refResult = REFS.get(current);
+  if (refResult != null) {
+    if (ASSIGNED_REFS.has(refResult)) {
+      return { referred: getRefParam(refResult) };
+    }
+    ASSIGNED_REFS.add(refResult);
+  }
+  if (constructorCheck(current, Set)) {
+    if (current.size) {
+      const values = [];
+      STACK.add(current);
+      for (const value2 of current.keys()) {
+        if (STACK.has(value2)) {
+          if (refResult == null) {
+            refResult = createRef(current);
+          }
+          createSetAdd(refResult, getRefParam(createRef(value2)));
+        } else {
+          const result = traverse(value2);
+          if (typeof result === "string") {
+            values.push(result);
+          } else {
+            values.push(result.referred);
+          }
+        }
+      }
+      STACK.delete(current);
+      const value = values.length ? `new Set([${join(values, ",")}])` : EMPTY_SET;
+      if (refResult != null) {
+        return assignRef(refResult, value);
+      }
+      return value;
+    }
+    return EMPTY_SET;
+  }
+  if (constructorCheck(current, Map)) {
+    if (current.size) {
+      const values = [];
+      STACK.add(current);
+      for (const [key, value2] of current.entries()) {
+        if (STACK.has(key)) {
+          if (refResult == null) {
+            refResult = createRef(current);
+          }
+          const keyRef = getRefParam(createRef(key));
+          if (STACK.has(value2)) {
+            createMapSet(refResult, keyRef, getRefParam(createRef(value2)));
+          } else {
+            const valueResult = traverse(value2);
+            if (typeof valueResult === "string") {
+              createMapSet(refResult, keyRef, valueResult);
+            } else {
+              createMapSet(refResult, keyRef, valueResult.referred);
+            }
+          }
+        } else if (STACK.has(value2)) {
+          if (refResult == null) {
+            refResult = createRef(current);
+          }
+          const valueRef = getRefParam(createRef(value2));
+          const keyResult = traverse(key);
+          if (typeof keyResult === "string") {
+            createMapSet(refResult, keyResult, valueRef);
+          } else {
+            createMapSet(refResult, keyResult.referred, valueRef);
+          }
+        } else {
+          const keyResult = traverse(key);
+          const valueResult = traverse(value2);
+          if (typeof keyResult === "string") {
+            if (typeof valueResult === "string") {
+              values.push(`[${keyResult},${valueResult}]`);
+            } else {
+              values.push(`[${keyResult},${valueResult.referred}]`);
+            }
+          } else {
+            if (typeof valueResult === "string") {
+              values.push(`[${keyResult.referred},${valueResult}]`);
+            } else {
+              values.push(`[${keyResult.referred},${valueResult.referred}]`);
+            }
+          }
+        }
+      }
+      STACK.delete(current);
+      const value = values.length ? `new Map([${join(values, ",")}])` : EMPTY_MAP;
+      if (refResult != null) {
+        return assignRef(refResult, value);
+      }
+      return value;
+    }
+    return EMPTY_MAP;
+  }
+  if (Array.isArray(current)) {
+    if (current.length) {
+      let values = "";
+      STACK.add(current);
+      forEach(current, (item, i) => {
+        if (i in current) {
+          if (STACK.has(item)) {
+            if (refResult == null) {
+              refResult = createRef(current);
+            }
+            createArrayAssign(refResult, i, getRefParam(createRef(item)));
+            values += ",";
+          } else {
+            const result = traverse(item);
+            if (typeof result === "string") {
+              values += result;
+            } else {
+              values += result.referred;
+            }
+            if (i < current.length - 1) {
+              values += ",";
+            }
+          }
+        } else {
+          values += ",";
+        }
+      });
+      STACK.delete(current);
+      const value = `[${values}]`;
+      if (refResult != null) {
+        return assignRef(refResult, value);
+      }
+      return value;
+    }
+    return EMPTY_ARRAY;
+  }
+  if (current.constructor === Object) {
+    const values = [];
+    STACK.add(current);
+    forEach(Object.entries(current), ([key, value2]) => {
+      const check = Number(key);
+      if (Number.isNaN(check) || /^([$A-Z_][0-9A-Z_$]*)$/i.test(key)) {
+        if (STACK.has(value2)) {
+          if (refResult == null) {
+            refResult = createRef(current);
+          }
+          createObjectIdentifierAssign(refResult, key, getRefParam(createRef(value2)));
+        } else {
+          const result = traverse(value2);
+          if (typeof result === "string") {
+            values.push(`${key}:${result}`);
+          } else {
+            values.push(`${key}:${result.referred}`);
+          }
+        }
+      } else if (STACK.has(value2)) {
+        if (refResult == null) {
+          refResult = createRef(current);
+        }
+        createObjectStringAssign(refResult, key, getRefParam(createRef(value2)));
+      } else {
+        const result = traverse(value2);
+        if (typeof result === "string") {
+          values.push(`${quote(key)}:${result}`);
+        } else {
+          values.push(`${quote(key)}:${result.referred}`);
+        }
+      }
+    });
+    STACK.delete(current);
+    const value = `{${join(values, ",")}}`;
+    if (refResult != null) {
+      return assignRef(refResult, value);
+    }
+    return value;
+  }
+  throw new Error("Unserializable value");
+}
+function serialize(source) {
+  if (isPrimitive(source)) {
+    return serializePrimitive(source);
+  }
+  reset();
+  lookupRefs(source);
+  for (const [key, value] of REF_COUNT.entries()) {
+    if (value > 1) {
+      createRef(key);
+    }
+  }
+  const result = traverse(source);
+  if (typeof result !== "string") {
+    throw new Error("Unreachable error");
+  }
+  if (VARS.length) {
+    const index = getRefParam(createRef(source));
+    const patches = resolvePatches();
+    const params = VARS.length > 1 ? `(${join(VARS, ",")})` : VARS[0];
+    if (result.startsWith(index)) {
+      return `(${params}=>(${result},${patches}${index}))()`;
+    }
+    return `(${params}=>(${index}=${result},${patches}${index}))()`;
+  }
+  if (source.constructor === Object) {
+    return `(${result})`;
+  }
+  return result;
+}
+//# sourceMappingURL=index.cjs.map