@qrkit/bc-ur 2.0.0-beta.9-qrkit.1

package/dist/web/bytewords.js

@@ -0,0 +1,335 @@
+BigInt("0xffffffffffffffff");
+
+const CRC32_TABLE = new Uint32Array(256);
+for (let i = 0; i < 256; i++) {
+    let c = i;
+    for (let j = 0; j < 8; j++) {
+        c = (c & 1) !== 0 ? (0xedb88320 ^ (c >>> 1)) : (c >>> 1);
+    }
+    CRC32_TABLE[i] = c >>> 0;
+}
+function crc32(message) {
+    let crc = 0xffffffff;
+    for (const byte of message) {
+        crc = CRC32_TABLE[(crc ^ byte) & 0xff] ^ (crc >>> 8);
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+}
+
+// Taken from uint8array-extras "^1.4.0" package
+// https://github.com/sindresorhus/uint8array-extras
+const objectToString = Object.prototype.toString;
+const uint8ArrayStringified = '[object Uint8Array]';
+function isType(value, typeConstructor, typeStringified) {
+    if (!value) {
+        return false;
+    }
+    if (value.constructor === typeConstructor) {
+        return true;
+    }
+    return objectToString.call(value) === typeStringified;
+}
+/**
+Check if the given value is an instance of `Uint8Array`.
+
+Replacement for [`Buffer.isBuffer()`](https://nodejs.org/api/buffer.html#static-method-bufferisbufferobj).
+
+@example
+```
+import {isUint8Array} from 'uint8array-extras';
+
+console.log(isUint8Array(new Uint8Array()));
+//=> true
+
+console.log(isUint8Array(Buffer.from('x')));
+//=> true
+
+console.log(isUint8Array(new ArrayBuffer(10)));
+//=> false
+```
+*/
+function isUint8Array(value) {
+    return isType(value, Uint8Array, uint8ArrayStringified);
+}
+/**
+Throw a `TypeError` if the given value is not an instance of `Uint8Array`.
+
+@example
+```
+import {assertUint8Array} from 'uint8array-extras';
+
+try {
+    assertUint8Array(new ArrayBuffer(10)); // Throws a TypeError
+} catch (error) {
+    console.error(error.message);
+}
+```
+*/
+function assertUint8Array(value) {
+    if (!isUint8Array(value)) {
+        throw new TypeError(`Expected \`Uint8Array\`, got \`${typeof value}\``);
+    }
+}
+function miniTextDecoder() {
+    return {
+        decode(input) {
+            const uint8Array = input instanceof Uint8Array ? input : new Uint8Array(input);
+            let result = '';
+            for (let i = 0; i < uint8Array.length; i++) {
+                result += String.fromCharCode(uint8Array[i]);
+            }
+            return result;
+        }
+    };
+}
+({
+    // Use TextDecoder if available (web, Node.js), otherwise use miniTextDecoder for React Native
+    utf8: typeof globalThis.TextDecoder !== 'undefined' ? new globalThis.TextDecoder('utf8') : miniTextDecoder(),
+});
+function assertString(value) {
+    if (typeof value !== 'string') {
+        throw new TypeError(`Expected \`string\`, got \`${typeof value}\``);
+    }
+}
+new globalThis.TextEncoder();
+const byteToHexLookupTable = Array.from({ length: 256 }, (_, index) => index.toString(16).padStart(2, '0'));
+/**
+Convert a `Uint8Array` to a Hex string.
+
+Replacement for [`Buffer#toString('hex')`](https://nodejs.org/api/buffer.html#buftostringencoding-start-end).
+
+@example
+```
+import {uint8ArrayToHex} from 'uint8array-extras';
+
+const byteArray = new Uint8Array([72, 101, 108, 108, 111]);
+
+console.log(uint8ArrayToHex(byteArray));
+//=> '48656c6c6f'
+```
+*/
+function uint8ArrayToHex(array) {
+    assertUint8Array(array);
+    // Concatenating a string is faster than using an array.
+    let hexString = '';
+    // eslint-disable-next-line unicorn/no-for-loop -- Max performance is critical.
+    for (let index = 0; index < array.length; index++) {
+        hexString += byteToHexLookupTable[array[index]];
+    }
+    return hexString;
+}
+const hexToDecimalLookupTable = {
+    0: 0,
+    1: 1,
+    2: 2,
+    3: 3,
+    4: 4,
+    5: 5,
+    6: 6,
+    7: 7,
+    8: 8,
+    9: 9,
+    a: 10,
+    b: 11,
+    c: 12,
+    d: 13,
+    e: 14,
+    f: 15,
+    A: 10,
+    B: 11,
+    C: 12,
+    D: 13,
+    E: 14,
+    F: 15,
+};
+/**
+Convert a Hex string to a `Uint8Array`.
+
+Replacement for [`Buffer.from('48656c6c6f', 'hex')`](https://nodejs.org/api/buffer.html#static-method-bufferfromstring-encoding).
+
+@example
+```
+import {hexToUint8Array} from 'uint8array-extras';
+
+console.log(hexToUint8Array('48656c6c6f'));
+//=> Uint8Array [72, 101, 108, 108, 111]
+```
+*/
+function hexToUint8Array(hexString) {
+    assertString(hexString);
+    if (hexString.length % 2 !== 0) {
+        throw new Error('Invalid Hex string length.');
+    }
+    const resultLength = hexString.length / 2;
+    const bytes = new Uint8Array(resultLength);
+    for (let index = 0; index < resultLength; index++) {
+        const highNibble = hexToDecimalLookupTable[hexString[index * 2]];
+        const lowNibble = hexToDecimalLookupTable[hexString[(index * 2) + 1]];
+        if (highNibble === undefined || lowNibble === undefined) {
+            throw new Error(`Invalid Hex character encountered at position ${index * 2}`);
+        }
+        bytes[index] = (highNibble << 4) | lowNibble; // eslint-disable-line no-bitwise
+    }
+    return bytes;
+}
+// concatUint8Arrays
+// stringToUint8Array
+// toUint8Array
+// hexToUint8Array
+// uint8ArrayToHex
+
+const partition = (s, n) => s.match(new RegExp(".{1," + n + "}", "g")) || [s];
+const split = (s, length) => [s.slice(0, -4), s.slice(-4)];
+const getCRCHex = (message) => crc32(message).toString(16).padStart(8, "0");
+function assert(condition, message) {
+    if (!condition) {
+        throw new Error(message || "Assertion failed");
+    }
+}
+
+const bytewords = "ableacidalsoapexaquaarchatomauntawayaxisbackbaldbarnbeltbetabiasbluebodybragbrewbulbbuzzcalmcashcatschefcityclawcodecolacookcostcruxcurlcuspcyandarkdatadaysdelidicedietdoordowndrawdropdrumdulldutyeacheasyechoedgeepicevenexamexiteyesfactfairfernfigsfilmfishfizzflapflewfluxfoxyfreefrogfuelfundgalagamegeargemsgiftgirlglowgoodgraygrimgurugushgyrohalfhanghardhawkheathelphighhillholyhopehornhutsicedideaidleinchinkyintoirisironitemjadejazzjoinjoltjowljudojugsjumpjunkjurykeepkenokeptkeyskickkilnkingkitekiwiknoblamblavalazyleaflegsliarlimplionlistlogoloudloveluaulucklungmainmanymathmazememomenumeowmildmintmissmonknailnavyneednewsnextnoonnotenumbobeyoboeomitonyxopenovalowlspaidpartpeckplaypluspoempoolposepuffpumapurrquadquizraceramprealredorichroadrockroofrubyruinrunsrustsafesagascarsetssilkskewslotsoapsolosongstubsurfswantacotasktaxitenttiedtimetinytoiltombtoystriptunatwinuglyundouniturgeuservastveryvetovialvibeviewvisavoidvowswallwandwarmwaspwavewaxywebswhatwhenwhizwolfworkyankyawnyellyogayurtzapszerozestzinczonezoom";
+let bytewordsLookUpTable = [];
+const BYTEWORDS_NUM = 256;
+const BYTEWORD_LENGTH = 4;
+const MINIMAL_BYTEWORD_LENGTH = 2;
+var STYLES;
+(function (STYLES) {
+    STYLES["STANDARD"] = "standard";
+    STYLES["URI"] = "uri";
+    STYLES["MINIMAL"] = "minimal";
+})(STYLES || (STYLES = {}));
+const getWord = (index) => {
+    return bytewords.slice(index * BYTEWORD_LENGTH, index * BYTEWORD_LENGTH + BYTEWORD_LENGTH);
+};
+const getMinimalWord = (index) => {
+    const byteword = getWord(index);
+    return `${byteword[0]}${byteword[BYTEWORD_LENGTH - 1]}`;
+};
+const addCRC = (string) => {
+    const crc = getCRCHex(hexToUint8Array(string));
+    return `${string}${crc}`;
+};
+const encodeWithSeparator = (word, separator, includeChecksum) => {
+    const crcAppendedWord = includeChecksum ? addCRC(word) : word;
+    const crcWordArray = hexToUint8Array(crcAppendedWord);
+    const result = crcWordArray.reduce((result, w) => [...result, getWord(w)], []);
+    return result.join(separator);
+};
+const encodeMinimal = (word, includeChecksum) => {
+    const crcAppendedWord = includeChecksum ? addCRC(word) : word;
+    const crcWordArray = hexToUint8Array(crcAppendedWord);
+    const result = crcWordArray.reduce((result, w) => result + getMinimalWord(w), "");
+    return result;
+};
+const decodeWord = (word, wordLength) => {
+    assert(word.length === wordLength, "Invalid Bytewords: word.length does not match wordLength provided");
+    const dim = 26;
+    // Since the first and last letters of each Byteword are unique,
+    // we can use them as indexes into a two-dimensional lookup table.
+    // This table is generated lazily.
+    if (bytewordsLookUpTable.length === 0) {
+        const array_len = dim * dim;
+        bytewordsLookUpTable = [...new Array(array_len)].map(() => -1);
+        for (let i = 0; i < BYTEWORDS_NUM; i++) {
+            const byteword = getWord(i);
+            let x = byteword[0].charCodeAt(0) - "a".charCodeAt(0);
+            let y = byteword[3].charCodeAt(0) - "a".charCodeAt(0);
+            let offset = y * dim + x;
+            bytewordsLookUpTable[offset] = i;
+        }
+    }
+    // If the coordinates generated by the first and last letters are out of bounds,
+    // or the lookup table contains -1 at the coordinates, then the word is not valid.
+    let x = word[0].toLowerCase().charCodeAt(0) - "a".charCodeAt(0);
+    let y = word[wordLength == 4 ? 3 : 1].toLowerCase().charCodeAt(0) -
+        "a".charCodeAt(0);
+    assert(0 <= x && x < dim && 0 <= y && y < dim, "Invalid Bytewords: invalid word");
+    let offset = y * dim + x;
+    let value = bytewordsLookUpTable[offset];
+    assert(value !== -1, "Invalid Bytewords: value not in lookup table");
+    // If we're decoding a full four-letter word, verify that the two middle letters are correct.
+    if (wordLength == BYTEWORD_LENGTH) {
+        const byteword = getWord(value);
+        let c1 = word[1].toLowerCase();
+        let c2 = word[2].toLowerCase();
+        assert(c1 === byteword[1] && c2 === byteword[2], "Invalid Bytewords: invalid middle letters of word");
+    }
+    // Successful decode.
+    return value.toString(16).padStart(2, "0");
+};
+/**
+ * Decode a string of Bytewords into a hex string.
+ * @param string string of Bytewords. e.g. "lpamchcfatttcyclehgsdphdhgehfghkkkdl..."
+ * @param separator e.g. " " or "-" or "" or any other separator
+ * @param wordLength e.g. 4 or 2 or any other length
+ * @param includeChecksum whether to include checksum in the decoding.
+ * @returns hex string
+ */
+const _decode = (string, separator, wordLength, includeChecksum) => {
+    // Split the string into words. e.g. ["lp", "am", "ch", "cf", "at", "tt", "cy", "cl", "eh", "gs", "dp", "hd", "hg", "eh", "fg", "hk", "kk", "dl", ...]
+    const words = wordLength == BYTEWORD_LENGTH
+        ? string.split(separator)
+        : partition(string, 2);
+    // Decode each word. e.g. ["85", "06", "17", "19", "07", "d1", "1a", "21", "31", "4c", "2d", "58", "57", "31", "46", "59", "79", "2f", ...]
+    const decodedWords = words.map((word) => decodeWord(word, wordLength));
+    // e.g. "8506171907d11a21314c2d5857314659792f..."
+    const decodedString = decodedWords.join("");
+    if (includeChecksum) {
+        // 4 bytes for checksum, at least 1 byte for body
+        assert(decodedString.length >= 5, "Invalid Bytewords: invalid decoded string length");
+        // decoded string consists of `body` and `checksum`
+        const decodedArray = hexToUint8Array(decodedString);
+        const [body, bodyChecksum] = split(decodedArray);
+        const checksum = getCRCHex(body); // convert to hex
+        assert(checksum === uint8ArrayToHex(bodyChecksum), "Invalid Checksum");
+        return uint8ArrayToHex(body);
+    }
+    else {
+        return decodedString;
+    }
+};
+/**
+ * Decode a string of bytewords into a hex string.
+ * @param string string of Bytewords
+ * @param style style of Bytewords
+ * @param includeChecksum whether to include checksum in the decoding.
+ * @returns hex string
+ */
+const decode = (string, style = STYLES.MINIMAL, includeChecksum = true) => {
+    switch (style) {
+        case STYLES.STANDARD:
+            return _decode(string, " ", BYTEWORD_LENGTH, includeChecksum);
+        case STYLES.URI:
+            return _decode(string, "-", BYTEWORD_LENGTH, includeChecksum);
+        case STYLES.MINIMAL:
+            return _decode(string, "", MINIMAL_BYTEWORD_LENGTH, includeChecksum);
+        default:
+            throw new Error(`Invalid style ${style}`);
+    }
+};
+/**
+ * Encodes a string (hex representation of a buffer) into bytewords.
+ * @param string string to encode.
+ * @param style style to use for the encoding.
+ * @param includeChecksum whether to include checksum in the encoding.
+ * @returns the byteword encoded string
+ */
+const encode = (string, style = STYLES.MINIMAL, includeChecksum = true) => {
+    switch (style) {
+        case STYLES.STANDARD:
+            return encodeWithSeparator(string, " ", includeChecksum);
+        case STYLES.URI:
+            return encodeWithSeparator(string, "-", includeChecksum);
+        case STYLES.MINIMAL:
+            return encodeMinimal(string, includeChecksum);
+        default:
+            throw new Error(`Invalid style ${style}`);
+    }
+};
+var bytewords$1 = {
+    decode,
+    encode,
+    STYLES,
+};
+
+export { STYLES, decode, bytewords$1 as default, encode };

package/index.html

@@ -0,0 +1,98 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Bytewords Interface</title>
+  <style>
+    body {
+      font-family: Arial, sans-serif;
+      margin: 20px;
+    }
+    .container {
+      max-width: 600px;
+      margin: auto;
+    }
+    textarea {
+      width: 100%;
+      height: 100px;
+      margin-bottom: 10px;
+    }
+    .button-container {
+      display: flex;
+      justify-content: space-between;
+    }
+    button {
+      width: 48%;
+      padding: 10px;
+      margin-bottom: 10px;
+    }
+    select {
+      width: 100%;
+      padding: 10px;
+      margin-bottom: 10px;
+    }
+    .error {
+      color: red;
+      margin-top: 10px;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>Bytewords Interface</h1>
+    <label for="hexInput">Hex Input:</label>
+    <textarea id="hexInput"></textarea>
+    <label for="encodeStyle">Encode Style:</label>
+    <select id="encodeStyle">
+      <option value="minimal">Minimal</option>
+      <option value="standard">Standard</option>
+      <option value="uri">URI</option>
+    </select>
+    <label for="includeChecksum">
+      <input type="checkbox" id="includeChecksum" checked> Include Checksum
+    </label>
+    <div class="button-container">
+      <button id="encodeButton">Encode to Bytewords</button>
+      <button id="decodeButton">Decode to Hex</button>
+    </div>
+    <label for="bytewordsOutput">Bytewords Output:</label>
+    <textarea id="bytewordsOutput"></textarea>
+    <div id="error" class="error"></div>
+  </div>
+  <script type="module">
+    import { encode, decode, STYLES } from './dist/web/bytewords.js';
+
+    const showError = (message) => {
+      const errorDiv = document.getElementById('error');
+      errorDiv.textContent = message;
+    };
+
+    document.getElementById('encodeButton').addEventListener('click', () => {
+      try {
+        const hexInput = document.getElementById('hexInput').value.trim();
+        const encodeStyle = document.getElementById('encodeStyle').value;
+        const includeChecksum = document.getElementById('includeChecksum').checked;
+        const bytewordsOutput = encode(hexInput, STYLES[encodeStyle.toUpperCase()], includeChecksum);
+        document.getElementById('bytewordsOutput').value = bytewordsOutput;
+        showError(''); // Clear any previous error
+      } catch (error) {
+        showError(`Encoding Error: ${error.message}`);
+      }
+    });
+
+    document.getElementById('decodeButton').addEventListener('click', () => {
+      try {
+        const bytewordsInput = document.getElementById('bytewordsOutput').value;
+        const decodeStyle = document.getElementById('encodeStyle').value;
+        const includeChecksum = document.getElementById('includeChecksum').checked;
+        const hexOutput = decode(bytewordsInput, STYLES[decodeStyle.toUpperCase()], includeChecksum);
+        document.getElementById('hexInput').value = hexOutput;
+        showError(''); // Clear any previous error
+      } catch (error) {
+        showError(`Decoding Error: ${error.message}`);
+      }
+    });
+  </script>
+</body>
+</html>

package/package.json

@@ -0,0 +1,94 @@
+{
+  "name": "@qrkit/bc-ur",
+  "version": "2.0.0-beta.9-qrkit.1",
+  "author": "Irfan Bilaloğlu <irfanbilaloglu@gmail.com>, Pieter Uyttersprot <pieter.uyttersprot@ngrave.io>, Antonis Poulakis <antwnic4@gmail.com>",
+  "contributors": [
+    "Mladen Milankovic <developer@mmlado.com>"
+  ],
+  "description": "Browser-native JavaScript implementation of Blockchain Commons UR for Node.js, browsers, and React Native",
+  "license": "MIT",
+  "directories": {
+    "lib": "src",
+    "test": "tests"
+  },
+  "files": [
+    "src",
+    "dist",
+    "index.html"
+  ],
+  "scripts": {
+    "clean": "rimraf dist && rimraf tsconfig.tsbuildinfo",
+    "build": "yarn clean && yarn compile && node ./scripts/post.build.js",
+    "compile": "tshy && rollup -c && \\cp -f ./src/wrappers/cbor2Wrapper.ts ./dist/commonjs/wrappers/cbor2Wrapper.d.ts",
+    "test": "node --experimental-vm-modules node_modules/.bin/jest",
+    "prepublishOnly": "yarn build",
+    "lint": "eslint \"./src/**/*.{ts,tsx}\" --max-warnings=0",
+    "start": "live-server --watch=src,dist --port=8080"
+  },
+  "dependencies": {
+    "@bacons/text-decoder": "0.0.0",
+    "cbor2": "^1.8.0"
+  },
+  "devDependencies": {
+    "@amanda-mitchell/semantic-release-npm-multiple": "^3.17.0",
+    "@rollup/plugin-commonjs": "^28.0.2",
+    "@rollup/plugin-node-resolve": "^16.0.0",
+    "@types/jest": "^29.5.13",
+    "@types/node": "^22.7.4",
+    "jest": "^29.7.0",
+    "live-server": "^1.2.1",
+    "rimraf": "^6.0.1",
+    "rollup": "^4.28.1",
+    "rollup-plugin-node-polyfills": "^0.2.1",
+    "ts-jest": "^29.2.5",
+    "tshy": "^3.0.2",
+    "tslib": "^2.8.1",
+    "typescript": "5.6.2"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ngraveio/bc-ur.git"
+  },
+  "keywords": [
+    "bc-ur"
+  ],
+  "bugs": {
+    "url": "https://github.com/ngraveio/bc-ur/issues"
+  },
+  "homepage": "https://github.com/ngraveio/bc-ur#readme",
+  "tshy": {
+    "exports": {
+      "./package.json": "./package.json",
+      ".": "./src/index.ts"
+    },
+    "include": [
+      "./src/**/*.ts",
+      "./src/**/*.cts",
+      "./src/**/*.mts",
+      "./src/**/*.tsx",
+      "./src/**/*.json"
+    ]
+  },
+  "type": "module",
+  "types": "./dist/commonjs/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "react-native": {
+        "types": "./dist/commonjs/index-react-native.d.ts",
+        "default": "./dist/commonjs/index-react-native.js"
+      },
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/commonjs/index.d.ts",
+        "default": "./dist/commonjs/index.js"
+      }
+    }
+  },
+  "main": "./dist/commonjs/index.js",
+  "react-native": "./dist/commonjs/index-react-native.js",
+  "module": "./dist/esm/index.js"
+}