@stackline/stable-stringify 1.0.0

package/dist/index.cjs

@@ -0,0 +1,728 @@
+/*! @stackline/stable-stringify v1.0.0 | MIT */
+var StacklineStableStringifyModule = (() => {
+  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.js
+  var index_exports = {};
+  __export(index_exports, {
+    CanonicalizationError: () => CanonicalizationError,
+    StableStringifyLimitError: () => StableStringifyLimitError,
+    canonicalize: () => canonicalize,
+    canonicalizeBytes: () => canonicalizeBytes,
+    configure: () => configure,
+    default: () => index_default,
+    safeStringify: () => safeStringify,
+    stableStringify: () => stableStringify,
+    stringify: () => stringify
+  });
+  var hasOwn = Object.prototype.hasOwnProperty;
+  var propertyIsEnumerable = Object.prototype.propertyIsEnumerable;
+  var objectToString = Object.prototype.toString;
+  var OMIT = /* @__PURE__ */ Symbol("omit");
+  var ROOT_PATH = null;
+  var SAFE_DEFAULTS = Object.freeze({
+    bigint: "string",
+    cycleValue: "[Circular]",
+    maxDepth: 100,
+    maxEntries: 1e5,
+    maxLength: 1e6,
+    onCycle: "marker"
+  });
+  var CANONICAL_DEFAULTS = Object.freeze({
+    maxDepth: 1e3,
+    maxEntries: 1e5,
+    maxLength: 16 * 1024 * 1024
+  });
+  var StableStringifyLimitError = class extends RangeError {
+    constructor(kind, limit, path) {
+      const location = formatPath(path);
+      super(`Stable stringify ${kind} limit of ${limit} exceeded at ${location}`);
+      this.name = "StableStringifyLimitError";
+      this.code = "ERR_STABLE_STRINGIFY_LIMIT";
+      this.kind = kind;
+      this.limit = limit;
+      this.path = location;
+    }
+  };
+  var CanonicalizationError = class extends TypeError {
+    constructor(reason, path) {
+      const location = formatPath(path);
+      super(`JSON canonicalization failed at ${location}: ${reason}`);
+      this.name = "CanonicalizationError";
+      this.code = "ERR_JSON_CANONICALIZATION";
+      this.path = location;
+      this.reason = reason;
+    }
+  };
+  function stableStringify(value, inputOptions) {
+    const options = normalizeStableOptions(inputOptions);
+    return serialize(value, options, false);
+  }
+  var stringify = stableStringify;
+  function configure(inputDefaults) {
+    const defaults = typeof inputDefaults === "function" ? { cmp: inputDefaults } : normalizeInputObject(inputDefaults);
+    normalizeStableOptions(defaults);
+    return function configuredStableStringify(value, inputOptions) {
+      const overrides = typeof inputOptions === "function" ? { cmp: inputOptions } : normalizeInputObject(inputOptions);
+      return stableStringify(value, { ...defaults, ...overrides });
+    };
+  }
+  function safeStringify(value, replacer, space, inputOptions) {
+    const options = normalizeInputObject(inputOptions);
+    const stableOptions = {
+      ...SAFE_DEFAULTS,
+      ...options,
+      maxDepth: options.maxDepth === void 0 ? options.depthLimit : options.maxDepth,
+      maxEntries: options.maxEntries === void 0 ? options.edgesLimit : options.maxEntries,
+      replacer: replacer === void 0 ? options.replacer : replacer,
+      space: space === void 0 ? options.space : space
+    };
+    if (stableOptions.maxDepth === void 0) {
+      stableOptions.maxDepth = SAFE_DEFAULTS.maxDepth;
+    }
+    if (stableOptions.maxEntries === void 0) {
+      stableOptions.maxEntries = SAFE_DEFAULTS.maxEntries;
+    }
+    try {
+      return stableStringify(value, stableOptions);
+    } catch (error) {
+      if (options.throwOnError === true) throw error;
+      let name = "UnknownError";
+      try {
+        if (error && typeof error.name === "string") {
+          name = error.name.slice(0, 80);
+        }
+      } catch (e) {
+      }
+      return JSON.stringify(`[Unable to serialize: ${name}]`);
+    }
+  }
+  function canonicalize(value, inputOptions) {
+    const options = normalizeCanonicalOptions(inputOptions);
+    return serialize(value, options, true);
+  }
+  function canonicalizeBytes(value, inputOptions) {
+    return encodeUtf8(canonicalize(value, inputOptions));
+  }
+  function serialize(rootValue, options, canonical) {
+    const state = {
+      ancestors: /* @__PURE__ */ new WeakMap(),
+      canonical,
+      chunks: [],
+      entries: 0,
+      length: 0,
+      options
+    };
+    const holder = { "": rootValue };
+    const prepared = prepareValue(rootValue, holder, "", ROOT_PATH, state);
+    if (prepared === OMIT) return void 0;
+    const tasks = [
+      {
+        depth: 0,
+        path: ROOT_PATH,
+        prepared,
+        type: "value"
+      }
+    ];
+    while (tasks.length > 0) {
+      const task = tasks.pop();
+      if (task.type === "value") {
+        processValueTask(task, tasks, state);
+      } else {
+        processContainerTask(task, tasks, state);
+      }
+    }
+    return state.chunks.join("");
+  }
+  function processValueTask(task, tasks, state) {
+    if (task.prepared.kind === "primitive") {
+      append(state, task.prepared.text, task.path);
+      return;
+    }
+    const value = task.prepared.value;
+    const previousPath = state.ancestors.get(value);
+    if (previousPath !== void 0 || state.ancestors.has(value)) {
+      appendCycle(state, previousPath, task.path);
+      return;
+    }
+    enforceDepth(state, task.depth, task.path);
+    const isArray = Array.isArray(value);
+    if (state.canonical && !isArray) validateCanonicalObject(value, task.path);
+    state.ancestors.set(value, task.path);
+    const frame = createContainerFrame(
+      value,
+      isArray,
+      task.depth,
+      task.path,
+      state
+    );
+    append(state, isArray ? "[" : "{", task.path);
+    if (frame.total === 0) {
+      append(state, isArray ? "]" : "}", task.path);
+      state.ancestors.delete(value);
+      return;
+    }
+    tasks.push(frame);
+  }
+  function processContainerTask(frame, tasks, state) {
+    if (frame.index >= frame.total) {
+      if (frame.emitted && state.options.gap !== "") {
+        append(state, `
+${frame.indent}`, frame.path);
+      }
+      append(state, frame.isArray ? "]" : "}", frame.path);
+      state.ancestors.delete(frame.value);
+      return;
+    }
+    if (frame.isArray) {
+      const index = frame.index;
+      frame.index += 1;
+      const path = createPath(frame.path, index);
+      consumeEntry(state, path);
+      const rawValue = readArrayValue(frame.value, index, path, state);
+      let prepared = prepareValue(
+        rawValue,
+        frame.value,
+        String(index),
+        path,
+        state
+      );
+      if (prepared === OMIT) prepared = primitive("null");
+      appendItemPrefix(frame, path, state);
+      tasks.push(frame);
+      tasks.push({
+        depth: frame.depth + 1,
+        path,
+        prepared,
+        type: "value"
+      });
+      return;
+    }
+    while (frame.index < frame.total) {
+      const key = frame.keys[frame.index];
+      frame.index += 1;
+      const path = createPath(frame.path, key);
+      consumeEntry(state, path);
+      const rawValue = readObjectValue(frame.value, key, path, state);
+      const prepared = prepareValue(rawValue, frame.value, key, path, state);
+      if (prepared === OMIT) continue;
+      appendItemPrefix(frame, path, state);
+      append(state, JSON.stringify(key), path);
+      append(state, state.options.gap === "" ? ":" : ": ", path);
+      tasks.push(frame);
+      tasks.push({
+        depth: frame.depth + 1,
+        path,
+        prepared,
+        type: "value"
+      });
+      return;
+    }
+    tasks.push(frame);
+  }
+  function createContainerFrame(value, isArray, depth, path, state) {
+    let keys;
+    let total;
+    if (isArray) {
+      total = value.length;
+    } else {
+      keys = getObjectKeys(value, path, state);
+      total = keys.length;
+    }
+    return {
+      depth,
+      emitted: false,
+      indent: state.options.gap === "" ? "" : state.options.gap.repeat(depth),
+      index: 0,
+      isArray,
+      keys,
+      path,
+      total,
+      type: "container",
+      value
+    };
+  }
+  function getObjectKeys(value, path, state) {
+    let keys;
+    if (state.canonical || state.options.propertyList === void 0) {
+      keys = Object.keys(value);
+    } else {
+      keys = state.options.propertyList.slice();
+    }
+    if (state.canonical) {
+      rejectEnumerableSymbols(value, path);
+      for (const key of keys) {
+        if (hasLoneSurrogate(key)) {
+          throw new CanonicalizationError(
+            "property names must not contain lone UTF-16 surrogates",
+            createPath(path, key)
+          );
+        }
+      }
+      return keys.sort();
+    }
+    if (state.options.accessors !== "invoke") {
+      keys = keys.filter((key) => {
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (!descriptor || !descriptor.get && !descriptor.set) return true;
+        if (state.options.accessors === "throw") {
+          throw new TypeError(
+            `Refusing to invoke accessor at ${formatPath(createPath(path, key))}`
+          );
+        }
+        return false;
+      });
+    }
+    if (state.options.cmp) {
+      const comparator = state.options.cmp;
+      keys.sort(
+        (left, right) => comparator(
+          { key: left, value: readForComparator(value, left, path, state) },
+          { key: right, value: readForComparator(value, right, path, state) }
+        )
+      );
+    } else {
+      keys.sort();
+    }
+    return keys;
+  }
+  function prepareValue(rawValue, holder, key, path, state) {
+    if (state.canonical) return prepareCanonicalValue(rawValue, path);
+    let value = rawValue;
+    if (state.options.toJSON && value !== null && value !== void 0) {
+      const method = value.toJSON;
+      if (typeof method === "function") value = method.call(value);
+    }
+    if (state.options.replacerFunction) {
+      value = state.options.replacerFunction.call(holder, key, value);
+    }
+    if (value === null) return primitive("null");
+    switch (typeof value) {
+      case "string":
+        return primitive(JSON.stringify(value));
+      case "number":
+        return primitive(Number.isFinite(value) ? String(value) : "null");
+      case "boolean":
+        return primitive(value ? "true" : "false");
+      case "bigint":
+        return prepareBigInt(value, state.options.bigint, path);
+      case "object":
+        return { kind: "object", value };
+      default:
+        return OMIT;
+    }
+  }
+  function prepareCanonicalValue(value, path) {
+    if (value === null) return primitive("null");
+    switch (typeof value) {
+      case "string":
+        if (hasLoneSurrogate(value)) {
+          throw new CanonicalizationError(
+            "strings must not contain lone UTF-16 surrogates",
+            path
+          );
+        }
+        return primitive(JSON.stringify(value));
+      case "number":
+        if (!Number.isFinite(value)) {
+          throw new CanonicalizationError(
+            "NaN and Infinity are not valid I-JSON numbers",
+            path
+          );
+        }
+        return primitive(JSON.stringify(value));
+      case "boolean":
+        return primitive(value ? "true" : "false");
+      case "object":
+        return { kind: "object", value };
+      case "bigint":
+        throw new CanonicalizationError(
+          "BigInt values must be represented as JSON strings",
+          path
+        );
+      default:
+        throw new CanonicalizationError(
+          `values of type ${typeof value} are not valid JSON data`,
+          path
+        );
+    }
+  }
+  function prepareBigInt(value, mode, path) {
+    if (mode === "string") return primitive(JSON.stringify(String(value)));
+    if (mode === "number") {
+      const number = Number(value);
+      if (!Number.isSafeInteger(number)) {
+        throw new RangeError(
+          `BigInt at ${formatPath(path)} cannot be represented as a safe JSON number`
+        );
+      }
+      return primitive(String(number));
+    }
+    throw new TypeError("Do not know how to serialize a BigInt");
+  }
+  function primitive(text) {
+    return { kind: "primitive", text };
+  }
+  function readArrayValue(array, index, path, state) {
+    if (state.canonical) {
+      if (!hasOwn.call(array, index)) {
+        throw new CanonicalizationError(
+          "sparse arrays are not valid I-JSON data",
+          path
+        );
+      }
+      return readCanonicalDescriptor(array, String(index), path);
+    }
+    return readStableProperty(array, String(index), path, state.options.accessors);
+  }
+  function readObjectValue(object, key, path, state) {
+    if (state.canonical) return readCanonicalDescriptor(object, key, path);
+    return readStableProperty(object, key, path, state.options.accessors);
+  }
+  function readCanonicalDescriptor(object, key, path) {
+    const descriptor = Object.getOwnPropertyDescriptor(object, key);
+    if (!descriptor || descriptor.get || descriptor.set) {
+      throw new CanonicalizationError(
+        "accessor properties are not valid canonical JSON input",
+        path
+      );
+    }
+    return descriptor.value;
+  }
+  function readStableProperty(object, key, path, accessors) {
+    if (accessors === "invoke") return object[key];
+    const seen = /* @__PURE__ */ new WeakSet();
+    let current = object;
+    while (current !== null && !seen.has(current)) {
+      seen.add(current);
+      const descriptor = Object.getOwnPropertyDescriptor(current, key);
+      if (descriptor) {
+        if (!descriptor.get && !descriptor.set) return descriptor.value;
+        if (accessors === "throw") {
+          throw new TypeError(`Refusing to invoke accessor at ${formatPath(path)}`);
+        }
+        return void 0;
+      }
+      current = Object.getPrototypeOf(current);
+    }
+    return void 0;
+  }
+  function readForComparator(object, key, path, state) {
+    return readStableProperty(
+      object,
+      key,
+      createPath(path, key),
+      state.options.accessors
+    );
+  }
+  function validateCanonicalObject(value, path) {
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== null && objectToString.call(value) !== "[object Object]") {
+      throw new CanonicalizationError(
+        "only JSON objects and arrays can be canonicalized",
+        path
+      );
+    }
+    if (prototype !== null && Object.getPrototypeOf(prototype) !== null) {
+      throw new CanonicalizationError(
+        "class instances must be converted to plain JSON objects",
+        path
+      );
+    }
+  }
+  function rejectEnumerableSymbols(value, path) {
+    if (typeof Object.getOwnPropertySymbols !== "function") return;
+    const symbols = Object.getOwnPropertySymbols(value);
+    if (symbols.some((symbol) => propertyIsEnumerable.call(value, symbol))) {
+      throw new CanonicalizationError(
+        "symbol properties are not valid JSON object members",
+        path
+      );
+    }
+  }
+  function appendItemPrefix(frame, path, state) {
+    if (state.options.gap === "") {
+      if (frame.emitted) append(state, ",", path);
+    } else {
+      const indentation = state.options.gap.repeat(frame.depth + 1);
+      append(state, frame.emitted ? `,
+${indentation}` : `
+${indentation}`, path);
+    }
+    frame.emitted = true;
+  }
+  function appendCycle(state, previousPath, currentPath) {
+    if (state.canonical) {
+      throw new CanonicalizationError("circular references are not valid JSON", currentPath);
+    }
+    switch (state.options.onCycle) {
+      case "marker":
+        append(state, JSON.stringify(state.options.cycleValue), currentPath);
+        return;
+      case "path":
+        append(
+          state,
+          JSON.stringify(`[Circular ${formatPath(previousPath)}]`),
+          currentPath
+        );
+        return;
+      case "null":
+        append(state, "null", currentPath);
+        return;
+      default:
+        throw new TypeError("Converting circular structure to JSON");
+    }
+  }
+  function append(state, text, path) {
+    const nextLength = state.length + text.length;
+    if (nextLength > state.options.maxLength) {
+      throw new StableStringifyLimitError(
+        "length",
+        state.options.maxLength,
+        path
+      );
+    }
+    state.length = nextLength;
+    state.chunks.push(text);
+  }
+  function enforceDepth(state, depth, path) {
+    if (depth > state.options.maxDepth) {
+      throw new StableStringifyLimitError(
+        "depth",
+        state.options.maxDepth,
+        path
+      );
+    }
+  }
+  function consumeEntry(state, path) {
+    state.entries += 1;
+    if (state.entries > state.options.maxEntries) {
+      throw new StableStringifyLimitError(
+        "entry",
+        state.options.maxEntries,
+        path
+      );
+    }
+  }
+  function normalizeStableOptions(inputOptions) {
+    const input = typeof inputOptions === "function" ? { cmp: inputOptions } : normalizeInputObject(inputOptions);
+    if (input.cmp !== void 0 && typeof input.cmp !== "function") {
+      throw new TypeError("cmp must be a function");
+    }
+    if (input.cycles !== void 0 && typeof input.cycles !== "boolean") {
+      throw new TypeError("cycles must be a boolean");
+    }
+    if (input.replacer !== void 0 && input.replacer !== null && typeof input.replacer !== "function" && !Array.isArray(input.replacer)) {
+      throw new TypeError("replacer must be a function or an array");
+    }
+    const onCycle = input.onCycle === void 0 ? input.cycles === true ? "marker" : "throw" : input.onCycle;
+    if (!["throw", "marker", "path", "null"].includes(onCycle)) {
+      throw new TypeError(
+        "onCycle must be 'throw', 'marker', 'path', or 'null'"
+      );
+    }
+    const bigint = input.bigint === void 0 ? "throw" : input.bigint;
+    if (!["throw", "string", "number"].includes(bigint)) {
+      throw new TypeError("bigint must be 'throw', 'string', or 'number'");
+    }
+    const accessors = input.accessors === void 0 ? "invoke" : input.accessors;
+    if (!["invoke", "omit", "throw"].includes(accessors)) {
+      throw new TypeError("accessors must be 'invoke', 'omit', or 'throw'");
+    }
+    if (input.toJSON !== void 0 && typeof input.toJSON !== "boolean") {
+      throw new TypeError("toJSON must be a boolean");
+    }
+    if (input.cycleValue !== void 0 && typeof input.cycleValue !== "string") {
+      throw new TypeError("cycleValue must be a string");
+    }
+    return {
+      accessors,
+      bigint,
+      cmp: input.cmp,
+      cycleValue: input.cycleValue === void 0 ? "__cycle__" : input.cycleValue,
+      gap: normalizeGap(input.space),
+      maxDepth: normalizeLimit(input.maxDepth, Infinity, "maxDepth"),
+      maxEntries: normalizeLimit(input.maxEntries, Infinity, "maxEntries"),
+      maxLength: normalizeLimit(input.maxLength, Infinity, "maxLength"),
+      onCycle,
+      propertyList: Array.isArray(input.replacer) ? normalizePropertyList(input.replacer) : void 0,
+      replacerFunction: typeof input.replacer === "function" ? input.replacer : void 0,
+      toJSON: input.toJSON === void 0 ? true : input.toJSON
+    };
+  }
+  function normalizeCanonicalOptions(inputOptions) {
+    const input = normalizeInputObject(inputOptions);
+    return {
+      accessors: "throw",
+      bigint: "throw",
+      cmp: void 0,
+      cycleValue: "",
+      gap: "",
+      maxDepth: normalizeLimit(
+        input.maxDepth,
+        CANONICAL_DEFAULTS.maxDepth,
+        "maxDepth"
+      ),
+      maxEntries: normalizeLimit(
+        input.maxEntries,
+        CANONICAL_DEFAULTS.maxEntries,
+        "maxEntries"
+      ),
+      maxLength: normalizeLimit(
+        input.maxLength,
+        CANONICAL_DEFAULTS.maxLength,
+        "maxLength"
+      ),
+      onCycle: "throw",
+      propertyList: void 0,
+      replacerFunction: void 0,
+      toJSON: false
+    };
+  }
+  function normalizeInputObject(value) {
+    if (value === void 0 || value === null) return {};
+    if (typeof value !== "object") {
+      throw new TypeError("options must be an object when provided");
+    }
+    return { ...value };
+  }
+  function normalizeLimit(value, fallback, name) {
+    const resolved = value === void 0 ? fallback : value;
+    if (resolved === Infinity) return resolved;
+    if (!Number.isSafeInteger(resolved) || resolved < 0) {
+      throw new TypeError(
+        `${name} must be a non-negative safe integer or Infinity`
+      );
+    }
+    return resolved;
+  }
+  function normalizeGap(space) {
+    if (typeof space === "number") {
+      return " ".repeat(Math.min(10, Math.max(0, Math.trunc(space))));
+    }
+    if (typeof space === "string") return space.slice(0, 10);
+    return "";
+  }
+  function normalizePropertyList(input) {
+    const output = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const item of input) {
+      let key;
+      if (typeof item === "string" || typeof item === "number") {
+        key = String(item);
+      } else if (item && (objectToString.call(item) === "[object String]" || objectToString.call(item) === "[object Number]")) {
+        key = String(item);
+      }
+      if (key !== void 0 && !seen.has(key)) {
+        seen.add(key);
+        output.push(key);
+      }
+    }
+    return output;
+  }
+  function hasLoneSurrogate(value) {
+    for (let index = 0; index < value.length; index += 1) {
+      const code = value.charCodeAt(index);
+      if (code >= 55296 && code <= 56319) {
+        const next = value.charCodeAt(index + 1);
+        if (!(next >= 56320 && next <= 57343)) return true;
+        index += 1;
+      } else if (code >= 56320 && code <= 57343) {
+        return true;
+      }
+    }
+    return false;
+  }
+  function createPath(parent, key) {
+    return { key, parent };
+  }
+  function formatPath(path) {
+    if (path === ROOT_PATH) return "<root>";
+    const parts = [];
+    let current = path;
+    while (current !== ROOT_PATH) {
+      parts.push(current.key);
+      current = current.parent;
+    }
+    parts.reverse();
+    let output = "<root>";
+    for (const part of parts) {
+      if (typeof part === "number") {
+        output += `[${part}]`;
+      } else if (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(part)) {
+        output += `.${part}`;
+      } else {
+        output += `[${JSON.stringify(part)}]`;
+      }
+    }
+    return output;
+  }
+  function encodeUtf8(value) {
+    if (typeof TextEncoder === "function") return new TextEncoder().encode(value);
+    const bytes = [];
+    for (let index = 0; index < value.length; index += 1) {
+      let code = value.charCodeAt(index);
+      if (code >= 55296 && code <= 56319) {
+        const next = value.charCodeAt(index + 1);
+        code = (code - 55296 << 10) + (next - 56320) + 65536;
+        index += 1;
+      }
+      if (code <= 127) {
+        bytes.push(code);
+      } else if (code <= 2047) {
+        bytes.push(192 | code >> 6, 128 | code & 63);
+      } else if (code <= 65535) {
+        bytes.push(
+          224 | code >> 12,
+          128 | code >> 6 & 63,
+          128 | code & 63
+        );
+      } else {
+        bytes.push(
+          240 | code >> 18,
+          128 | code >> 12 & 63,
+          128 | code >> 6 & 63,
+          128 | code & 63
+        );
+      }
+    }
+    return Uint8Array.from(bytes);
+  }
+  Object.defineProperties(stableStringify, {
+    CanonicalizationError: { value: CanonicalizationError },
+    StableStringifyLimitError: { value: StableStringifyLimitError },
+    canonicalize: { value: canonicalize },
+    canonicalizeBytes: { value: canonicalizeBytes },
+    configure: { value: configure },
+    default: { value: stableStringify },
+    safeStringify: { value: safeStringify },
+    stable: { value: stableStringify },
+    stableStringify: { value: stableStringify },
+    stringify: { value: stableStringify }
+  });
+  Object.defineProperties(safeStringify, {
+    stable: { value: stableStringify },
+    stableStringify: { value: stableStringify }
+  });
+  var index_default = stableStringify;
+  return __toCommonJS(index_exports);
+})();
+var stableStringifyExport = StacklineStableStringifyModule.default;
+module.exports = stableStringifyExport;
+//# sourceMappingURL=index.cjs.map