@vercel/stega 0.0.3 → 0.0.5

package/README.md

@@ -0,0 +1,52 @@
+# @vercel/stega
+
+A simple [steganography](https://en.wikipedia.org/wiki/Steganography) library for adding hidden JSON data to strings.
+
+## Usage
+
+This package exports a few methods for encoding and decoding data. All of these methods have TypeScript type definitions and JSDoc comments explaining their parameters and return values.
+
+### `vercelStegaCombine(string, json, skip = 'auto')`
+
+This method combines a `string` with some JSON data and returns the result. The `json` can be any value that can be JSON stringified.
+
+When the `skip` property is `true`, the original string will be returned without combining the `json`. It supports `boolean` values and `'auto'`. The default is `'auto'`, which will only skip encoding when the `string` is an ISO date string or a URL.
+
+```js
+vercelStegaCombine('Hello world', { foo: 'bar' });
+// -> 'Hello world' (the JSON data is hidden in the new string)
+```
+
+### `vercelStegaEncode(json)`
+
+This method encodes JSON data as a hidden string and returns the result. The `json` can be any value that can be JSON stringified.
+
+```js
+vercelStegaEncode({ foo: 'bar' });
+// -> '' (the JSON data is hidden)
+```
+
+### `vercelStegaSplit(string)`
+
+This method splits out the original string (cleaned) and the encoded portion of the string.
+
+```js
+// In 'Hello world' (the extra data is hidden)
+vercelStegaSplit('Hello world');
+/*
+ * -> {
+ *  cleaned: 'Hello world', // This doesn't contains the encoded data
+ *  encoded: '', // This is not an empty string, it contains the encoded data
+ * }
+ */
+```
+
+### `vercelStegaDecode(string)`
+
+This method attempts to extract encoded JSON data from a `string`.
+
+```js
+// In 'Hello world' (the extra data is hidden)
+vercelStegaDecode('Hello world');
+// -> { foo: 'bar' }
+```

package/dist/cjs/decode.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.vercelStegaDecode = exports.VERCEL_STEGA_REGEX = void 0;
+exports.vercelStegaDecodeAll = exports.vercelStegaDecode = exports.VERCEL_STEGA_REGEX = void 0;
 const map_1 = require("./map");
 const REVERSE_HEX_DIGIT_MAP = Object.fromEntries(Object.entries(map_1.HEX_DIGIT_MAP).map((x) => x.reverse()));
 const HEX_CHARS = `${Object.values(map_1.HEX_DIGIT_MAP)
@@ -8,18 +8,31 @@ const HEX_CHARS = `${Object.values(map_1.HEX_DIGIT_MAP)
     .join('')}`;
 exports.VERCEL_STEGA_REGEX = new RegExp(`(?:[${HEX_CHARS}]{2})+`, 'gu');
 /**
- * Decodes a hidden string back into its original value
- * @param encoded - The encoded (hidden) string
+ * Decodes the first hidden string that's found in the source string back into its original value
+ * @param source - The source string with encoded data
  * @returns The decoded JSON value
  */
-function vercelStegaDecode(encoded) {
-    const match = encoded.match(exports.VERCEL_STEGA_REGEX);
-    if (!match)
+function vercelStegaDecode(source) {
+    const matches = source.match(exports.VERCEL_STEGA_REGEX);
+    if (!matches)
         return;
-    return decode(match[0]);
+    return decode(matches[0], true)[0];
 }
 exports.vercelStegaDecode = vercelStegaDecode;
-function decode(encodedString) {
+/**
+ * Decodes every hidden string that's found in the source string back into their original values
+ * @param source - The source string with encoded data
+ * @returns The decoded JSON values
+ */
+function vercelStegaDecodeAll(source) {
+    const matches = source.match(exports.VERCEL_STEGA_REGEX);
+    if (!matches)
+        return;
+    return matches.map((match) => decode(match)).flat();
+}
+exports.vercelStegaDecodeAll = vercelStegaDecodeAll;
+function decode(encodedString, firstOnly = false) {
+    var _a;
     const encoded = Array.from(encodedString);
     if (encoded.length % 2) {
         throw new Error(`Invalid encoded text length. Expected length to be even, received: ${encoded.length}`);
@@ -29,5 +42,24 @@ function decode(encodedString) {
         const hex = `${REVERSE_HEX_DIGIT_MAP[encoded[i * 2].codePointAt(0)]}${REVERSE_HEX_DIGIT_MAP[encoded[i * 2 + 1].codePointAt(0)]}`;
         chars.unshift(String.fromCharCode(parseInt(hex, 16)));
     }
-    return JSON.parse(chars.join(''));
+    const results = [];
+    const queue = [chars.join('')];
+    let breakLimit = 10;
+    while (queue.length) {
+        const string = queue.shift();
+        try {
+            results.push(JSON.parse(string));
+            if (firstOnly)
+                return results;
+        }
+        catch (error) {
+            if (!breakLimit--)
+                throw error;
+            const position = +((_a = error.message.match(/\sposition\s(\d+)$/)) === null || _a === void 0 ? void 0 : _a[1]);
+            if (!position)
+                throw error;
+            queue.unshift(string.substring(0, position), string.substring(position));
+        }
+    }
+    return results;
 }

package/dist/cjs/encode.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.vercelStegaEncode = void 0;
+exports.vercelStegaCombine = exports.vercelStegaEncode = void 0;
 const map_1 = require("./map");
 /**
  * Encodes JSON as a hidden string
@@ -22,3 +22,29 @@ function vercelStegaEncode(json) {
         .join('');
 }
 exports.vercelStegaEncode = vercelStegaEncode;
+function isDate(string) {
+    return Boolean(Date.parse(string));
+}
+function isUrl(string) {
+    try {
+        new URL(string);
+    }
+    catch {
+        return false;
+    }
+    return true;
+}
+/**
+ * Adds an encoded JSON object to a string as hidden characters
+ * @param string - The string the JSON will be added to
+ * @param json - The JSON to add to the string
+ * @param skip - Whether to skip encoding (default: "auto")
+ */
+function vercelStegaCombine(string, json, skip = 'auto') {
+    if (skip === true)
+        return string;
+    if (skip === 'auto' && (isDate(string) || isUrl(string)))
+        return string;
+    return `${string}${vercelStegaEncode(json)}`;
+}
+exports.vercelStegaCombine = vercelStegaCombine;

package/dist/decode.d.ts

@@ -1,7 +1,13 @@
 export declare const VERCEL_STEGA_REGEX: RegExp;
 /**
- * Decodes a hidden string back into its original value
- * @param encoded - The encoded (hidden) string
+ * Decodes the first hidden string that's found in the source string back into its original value
+ * @param source - The source string with encoded data
  * @returns The decoded JSON value
  */
-export declare function vercelStegaDecode<T>(encoded: string): T | undefined;
+export declare function vercelStegaDecode<T>(source: string): T | undefined;
+/**
+ * Decodes every hidden string that's found in the source string back into their original values
+ * @param source - The source string with encoded data
+ * @returns The decoded JSON values
+ */
+export declare function vercelStegaDecodeAll<T>(source: string): T[];

package/dist/encode.d.ts

@@ -4,3 +4,12 @@
  * @returns The hidden string
  */
 export declare function vercelStegaEncode<T>(json: T): string;
+type SkipValue = 'auto' | boolean;
+/**
+ * Adds an encoded JSON object to a string as hidden characters
+ * @param string - The string the JSON will be added to
+ * @param json - The JSON to add to the string
+ * @param skip - Whether to skip encoding (default: "auto")
+ */
+export declare function vercelStegaCombine<T>(string: string, json: T, skip?: SkipValue): string;
+export {};

package/dist/esm/decode.js

@@ -5,17 +5,29 @@ const HEX_CHARS = `${Object.values(HEX_DIGIT_MAP)
     .join('')}`;
 export const VERCEL_STEGA_REGEX = new RegExp(`(?:[${HEX_CHARS}]{2})+`, 'gu');
 /**
- * Decodes a hidden string back into its original value
- * @param encoded - The encoded (hidden) string
+ * Decodes the first hidden string that's found in the source string back into its original value
+ * @param source - The source string with encoded data
  * @returns The decoded JSON value
  */
-export function vercelStegaDecode(encoded) {
-    const match = encoded.match(VERCEL_STEGA_REGEX);
-    if (!match)
+export function vercelStegaDecode(source) {
+    const matches = source.match(VERCEL_STEGA_REGEX);
+    if (!matches)
         return;
-    return decode(match[0]);
+    return decode(matches[0], true)[0];
 }
-function decode(encodedString) {
+/**
+ * Decodes every hidden string that's found in the source string back into their original values
+ * @param source - The source string with encoded data
+ * @returns The decoded JSON values
+ */
+export function vercelStegaDecodeAll(source) {
+    const matches = source.match(VERCEL_STEGA_REGEX);
+    if (!matches)
+        return;
+    return matches.map((match) => decode(match)).flat();
+}
+function decode(encodedString, firstOnly = false) {
+    var _a;
     const encoded = Array.from(encodedString);
     if (encoded.length % 2) {
         throw new Error(`Invalid encoded text length. Expected length to be even, received: ${encoded.length}`);
@@ -25,5 +37,24 @@ function decode(encodedString) {
         const hex = `${REVERSE_HEX_DIGIT_MAP[encoded[i * 2].codePointAt(0)]}${REVERSE_HEX_DIGIT_MAP[encoded[i * 2 + 1].codePointAt(0)]}`;
         chars.unshift(String.fromCharCode(parseInt(hex, 16)));
     }
-    return JSON.parse(chars.join(''));
+    const results = [];
+    const queue = [chars.join('')];
+    let breakLimit = 10;
+    while (queue.length) {
+        const string = queue.shift();
+        try {
+            results.push(JSON.parse(string));
+            if (firstOnly)
+                return results;
+        }
+        catch (error) {
+            if (!breakLimit--)
+                throw error;
+            const position = +((_a = error.message.match(/\sposition\s(\d+)$/)) === null || _a === void 0 ? void 0 : _a[1]);
+            if (!position)
+                throw error;
+            queue.unshift(string.substring(0, position), string.substring(position));
+        }
+    }
+    return results;
 }

package/dist/esm/encode.js

@@ -18,3 +18,28 @@ export function vercelStegaEncode(json) {
     })
         .join('');
 }
+function isDate(string) {
+    return Boolean(Date.parse(string));
+}
+function isUrl(string) {
+    try {
+        new URL(string);
+    }
+    catch {
+        return false;
+    }
+    return true;
+}
+/**
+ * Adds an encoded JSON object to a string as hidden characters
+ * @param string - The string the JSON will be added to
+ * @param json - The JSON to add to the string
+ * @param skip - Whether to skip encoding (default: "auto")
+ */
+export function vercelStegaCombine(string, json, skip = 'auto') {
+    if (skip === true)
+        return string;
+    if (skip === 'auto' && (isDate(string) || isUrl(string)))
+        return string;
+    return `${string}${vercelStegaEncode(json)}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/stega",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "Utilities for steganography",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",