@flickfyi/flkr 0.0.0 → 0.0.118

package/node_modules/@msgpackr-extract/msgpackr-extract-linux-x64/README.md

@@ -0,0 +1 @@
+Platform specific binary for msgpackr-extract on linux OS with x64 architecture

package/node_modules/@msgpackr-extract/{msgpackr-extract-darwin-arm64 → msgpackr-extract-linux-x64}/package.json

@@ -1,11 +1,11 @@
 {
-  "name": "@msgpackr-extract/msgpackr-extract-darwin-arm64",
+  "name": "@msgpackr-extract/msgpackr-extract-linux-x64",
   "version": "3.0.4",
   "os": [
-    "darwin"
+    "linux"
   ],
   "cpu": [
-    "arm64"
+    "x64"
   ],
   "license": "MIT",
   "author": "Kris Zyp",
@@ -13,5 +13,5 @@
     "type": "git",
     "url": "http://github.com/kriszyp/msgpackr-extract"
   },
-  "description": "Platform specific binary for msgpackr-extract on darwin OS with arm64 architecture"
+  "description": "Platform specific binary for msgpackr-extract on linux OS with x64 architecture"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flickfyi/flkr",
-  "version": "0.0.0",
+  "version": "0.0.118",
   "description": "A tool for managing your Flicks",
   "homepage": "https://flick.fyi/docs/flkr/quick-start",
   "bugs": {
@@ -41,10 +41,10 @@
   },
   "dependencies": {
     "@flickfyi/biscuit": "0.0.2",
-    "@flickfyi/core": "0.0.59",
+    "@flickfyi/core": "0.0.60",
     "@flickfyi/http-message-sig": "0.0.0",
     "@flickfyi/identity": "0.0.0",
-    "@flickfyi/photon": "0.0.28",
+    "@flickfyi/photon": "0.0.29",
     "@inkjs/ui": "2.0.0",
     "@noble/curves": "2.4.0",
     "@noble/hashes": "2.4.0",

package/node_modules/@flickfyi/identity/dist/base-ClGB6hXM.js

@@ -1,354 +0,0 @@
-//#region ../../../../../../.pnpm-store/v11/links/@scure/base/2.4.0/ad23daa89c8f818f846ea08cb1381ee92ffff82c746eeca32889ede9edde648d/node_modules/@scure/base/index.js
-/*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-var freeze = (fn) => Object.freeze(fn());
-function isBytes(a) {
-	return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array" && "BYTES_PER_ELEMENT" in a && a.BYTES_PER_ELEMENT === 1;
-}
-/** Asserts something is Uint8Array. */
-function abytes(b) {
-	if (!isBytes(b)) throw new TypeError("Uint8Array expected");
-}
-function astr(label, input) {
-	if (typeof input !== "string") throw new TypeError(`${label}: string expected`);
-	return true;
-}
-function anumber(n, title = "number") {
-	if (typeof n !== "number") throw new TypeError(`${title}: expected number, got ${typeof n}`);
-	if (!Number.isSafeInteger(n)) throw new RangeError(`${title}: expected safe integer, got ${n}`);
-}
-function chain(...args) {
-	const id = (a) => a;
-	const wrap = (a, b) => (c) => a(b(c));
-	return {
-		encode: args.map((x) => x.encode).reduceRight(wrap, id),
-		decode: args.map((x) => x.decode).reduce(wrap, id)
-	};
-}
-var powers = /* @__PURE__ */ (() => {
-	let res = [];
-	for (let i = 0; i < 40; i++) res.push(2 ** i);
-	return res;
-})();
-var asciiDecoder = /* @__PURE__ */ (() => {
-	try {
-		const decoder = new TextDecoder();
-		return decoder.decode(Uint8Array.of(65, 48, 43, 127)) === "A0+" ? decoder : void 0;
-	} catch (e) {
-		return;
-	}
-})();
-var B2S_CHUNK = 8192;
-function charcodesToString(codes) {
-	const len = codes.length;
-	if (asciiDecoder !== void 0 && len >= 12) return asciiDecoder.decode(codes);
-	if (len <= B2S_CHUNK) return String.fromCharCode.apply(null, codes);
-	let res = "";
-	for (let i = 0; i < len; i += B2S_CHUNK) res += String.fromCharCode.apply(null, codes.subarray(i, i + B2S_CHUNK));
-	return res;
-}
-/**
-* Linear 8 <-> bits regrouping (radix2Slow semantics), with Uint8Array digits and
-* preallocated output.
-*/
-function radix2(bits) {
-	anumber(bits);
-	if (bits <= 0 || bits > 8) throw new RangeError("radix2: bits should be in (0..8]");
-	const mask = powers[bits] - 1;
-	return {
-		encode: (bytes) => {
-			abytes(bytes);
-			const len = bytes.length;
-			const res = new Uint8Array(Math.ceil(len * 8 / bits));
-			let carry = 0;
-			let pos = 0;
-			let j = 0;
-			for (let i = 0; i < len;) {
-				if (i + 2 < len) {
-					carry = carry << 24 | bytes[i] << 16 | bytes[i + 1] << 8 | bytes[i + 2];
-					pos += 24;
-					i += 3;
-				} else {
-					carry = (carry << 8 | bytes[i]) & 65535;
-					pos += 8;
-					i++;
-				}
-				for (;;) {
-					pos -= bits;
-					res[j++] = carry >> pos & mask;
-					if (pos < bits) break;
-				}
-			}
-			if (pos > 0) res[j] = carry << bits - pos & mask;
-			return res;
-		},
-		decode: (digits) => {
-			const len = digits.length;
-			const res = new Uint8Array(Math.floor(len * bits / 8));
-			let carry = 0;
-			let pos = 0;
-			let j = 0;
-			for (let i = 0; i < len; i++) {
-				carry = (carry << bits | digits[i]) & 65535;
-				pos += bits;
-				for (; pos >= 8; pos -= 8) res[j++] = carry >> pos - 8 & 255;
-			}
-			carry = carry << 8 - pos & 255;
-			if (pos >= bits) throw new Error("Excess padding");
-			if (carry > 0) throw new Error(`Non-zero padding: ${carry}`);
-			return res;
-		}
-	};
-}
-/**
-* Digit <-> letter mapping fused with string join (chain(alphabetSlow(letters), join(''))
-* semantics), via char-code lookup tables.
-*/
-function alphabet(letters, aliases) {
-	const len = letters.length;
-	if (len > 128) throw new Error("alphabet: max 128 letters");
-	const encTable = new Uint8Array(len);
-	const decTable = (/* @__PURE__ */ new Int8Array(128)).fill(-1);
-	for (let i = 0; i < len; i++) {
-		const code = letters.charCodeAt(i);
-		if (letters.codePointAt(i) !== code || code > 127) throw new Error("alphabet: single-char ASCII letters only");
-		encTable[i] = code;
-		decTable[code] = i;
-	}
-	if (aliases !== void 0) for (const alias of Object.keys(aliases)) {
-		const code = alias.charCodeAt(0);
-		const target = decTable[aliases[alias].charCodeAt(0)];
-		if (alias.length !== 1 || code > 127 || target === void 0 || target === -1) throw new Error(`alphabet: invalid alias ${alias}`);
-		decTable[code] = target;
-	}
-	return {
-		encode: (digits) => {
-			const codes = new Uint8Array(digits.length);
-			for (let i = 0; i < digits.length; i++) {
-				const d = digits[i];
-				const code = encTable[d];
-				if (code === void 0) throw new Error(`alphabet.encode: invalid digit ${d}`);
-				codes[i] = code;
-			}
-			return charcodesToString(codes);
-		},
-		decode: (input) => {
-			astr("decode", input);
-			const slen = input.length;
-			const digits = new Uint8Array(slen);
-			for (let i = 0; i < slen; i++) {
-				const code = input.charCodeAt(i);
-				const digit = code < 128 ? decTable[code] : -1;
-				if (digit === -1) throw new Error(`Unknown letter "${input[i]}". Allowed: ${letters}`);
-				digits[i] = digit;
-			}
-			return digits;
-		}
-	};
-}
-/**
-* Pad / unpad (paddingSlow semantics), on the joined string.
-*/
-function padding(bits, chr = "=") {
-	anumber(bits);
-	astr("padding", chr);
-	return {
-		encode(data) {
-			while (data.length * bits % 8) data += chr;
-			return data;
-		},
-		decode(input) {
-			astr("decode", input);
-			let end = input.length;
-			if (end * bits % 8) throw new Error("padding: invalid length");
-			for (; end > 0 && input[end - 1] === chr; end--) if ((end - 1) * bits % 8 === 0) throw new Error("padding: excess padding");
-			return input.slice(0, end);
-		}
-	};
-}
-var hasBase64Builtin = /* @__PURE__ */ (() => typeof Uint8Array.from([]).toBase64 === "function" && typeof Uint8Array.fromBase64 === "function")();
-var ASCII_WHITESPACE = /[\t\n\f\r ]/;
-var decodeBase64Builtin = (s, isUrl) => {
-	astr("base64", s);
-	const alphabet = isUrl ? "base64url" : "base64";
-	if (s.length > 0 && ASCII_WHITESPACE.test(s)) throw new Error("invalid base64");
-	return Uint8Array.fromBase64(s, {
-		alphabet,
-		lastChunkHandling: "strict"
-	});
-};
-/** base64 from RFC 4648. Padded. Pure JS version */
-var base64Fallback = /* @__PURE__ */ freeze(() => chain(radix2(6), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"), padding(6)));
-/** base64url from RFC 4648. Padded. Pure JS version */
-var base64urlFallback = /* @__PURE__ */ freeze(() => chain(radix2(6), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"), padding(6)));
-/**
-* base64 from RFC 4648. Padded.
-* Alternative variants: `base64nopad`, `base64url`, `base64urlnopad`.
-* Utilizes native `Uint8Array.fromBase64` builtin, otherwise falls back to `base64fallback` when it's unavailable.
-* @example
-* ```js
-* base64.encode(Uint8Array.from([0x12, 0xab]));
-* // => 'Eqs='
-* base64.decode('Eqs=');
-* // => Uint8Array.from([0x12, 0xab])
-* ```
-*/
-var base64 = /* @__PURE__ */ freeze(() => hasBase64Builtin ? {
-	encode(b) {
-		abytes(b);
-		return b.toBase64();
-	},
-	decode(s) {
-		return decodeBase64Builtin(s, false);
-	}
-} : base64Fallback);
-/**
-* base64 from RFC 4648, using URL-safe alphabet. Padded.
-* Use `base64urlnopad` for unpadded version.
-* Falls back to built-in function, when available.
-* @example
-* ```js
-* base64url.encode(Uint8Array.from([0x12, 0xab]));
-* // => 'Eqs='
-* base64url.decode('Eqs=');
-* // => Uint8Array.from([0x12, 0xab])
-* ```
-*/
-var base64url = /* @__PURE__ */ freeze(() => hasBase64Builtin ? {
-	encode(b) {
-		abytes(b);
-		return b.toBase64({ alphabet: "base64url" });
-	},
-	decode(s) {
-		return decodeBase64Builtin(s, true);
-	}
-} : base64urlFallback);
-/**
-* base64 from RFC 4648, using URL-safe alphabet. No padding.
-* Use `base64url` for padded version.
-* @example
-* ```js
-* base64urlnopad.encode(Uint8Array.from([0x12, 0xab]));
-* // => 'Eqs'
-* base64urlnopad.decode('Eqs');
-* // => Uint8Array.from([0x12, 0xab])
-* ```
-*/
-var base64urlnopad = /* @__PURE__ */ freeze(() => chain(radix2(6), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_")));
-var B58_GROUP = 656356768;
-var RADIX_BASE_N_MAX_LENGTH = 65536;
-var BASE_N_MAX_BYTES = 2048;
-var BASE_N_MAX_CHARS = 4096;
-var radixBaseN = (BASE, GROUP) => ({
-	encode: (bytes) => {
-		abytes(bytes);
-		const blen = bytes.length;
-		if (blen === 0) return /* @__PURE__ */ new Uint8Array(0);
-		if (blen >= RADIX_BASE_N_MAX_LENGTH) throw new Error("invalid length");
-		let zeros = 0;
-		while (zeros < blen - 1 && bytes[zeros] === 0) zeros++;
-		const nlimbs = Math.ceil(blen / 2);
-		const limbs = new Uint16Array(nlimbs);
-		const odd = blen & 1;
-		if (odd) limbs[0] = bytes[0];
-		for (let i = odd, j = odd; i < blen; i += 2, j++) limbs[j] = bytes[i] << 8 | bytes[i + 1];
-		const groups = [];
-		let pos = 0;
-		while (pos < nlimbs) {
-			let carry = 0;
-			for (let i = pos; i < nlimbs; i++) {
-				const cur = carry * 65536 + limbs[i];
-				const q = Math.floor(cur / GROUP);
-				carry = cur - q * GROUP;
-				limbs[i] = q;
-				if (q === 0 && i === pos) pos++;
-			}
-			groups.push(carry);
-		}
-		const top = groups.length - 1;
-		let sig = top * 5;
-		for (let v = groups[top];; v = Math.floor(v / BASE)) {
-			sig++;
-			if (v < BASE) break;
-		}
-		const res = new Uint8Array(zeros + sig);
-		let j = res.length - 1;
-		for (let g = 0; g < top; g++) {
-			let v = groups[g];
-			for (let k = 0; k < 5; k++) {
-				res[j--] = v % BASE;
-				v = Math.floor(v / BASE);
-			}
-		}
-		for (let v = groups[top]; j >= zeros; v = Math.floor(v / BASE)) res[j--] = v % BASE;
-		return res;
-	},
-	decode: (digits) => {
-		abytes(digits);
-		const dlen = digits.length;
-		if (dlen === 0) return /* @__PURE__ */ new Uint8Array(0);
-		if (dlen >= RADIX_BASE_N_MAX_LENGTH) throw new Error("invalid length");
-		let zeros = 0;
-		while (zeros < dlen - 1 && digits[zeros] === 0) zeros++;
-		const limbs = new Uint16Array(Math.ceil(dlen * 6 / 16) + 1);
-		let used = 0;
-		let i = 0;
-		let group = dlen % 5 || 5;
-		while (i < dlen) {
-			let gval = 0;
-			let factor = 1;
-			for (const end = i + group; i < end; i++) {
-				const d = digits[i];
-				if (d >= BASE) throw new Error(`invalid integer: ${d}`);
-				gval = gval * BASE + d;
-				factor *= BASE;
-			}
-			group = 5;
-			let carry = gval;
-			for (let k = 0; k < used; k++) {
-				const cur = limbs[k] * factor + carry;
-				carry = Math.floor(cur / 65536);
-				limbs[k] = cur - carry * 65536;
-			}
-			for (; carry > 0; carry = Math.floor(carry / 65536)) limbs[used++] = carry % 65536;
-		}
-		const valueBytes = used === 0 ? 1 : used * 2 - (limbs[used - 1] < 256 ? 1 : 0);
-		const res = new Uint8Array(zeros + valueBytes);
-		let j = res.length - 1;
-		for (let k = 0; k < used; k++) {
-			const limb = limbs[k];
-			res[j--] = limb & 255;
-			if (j >= zeros) res[j--] = limb >> 8;
-		}
-		return res;
-	}
-});
-var genBaseN = (radix, abc) => {
-	const letters = alphabet(abc);
-	return {
-		encode(bytes) {
-			abytes(bytes);
-			if (bytes.length > BASE_N_MAX_BYTES) throw new Error("invalid length");
-			return letters.encode(radix.encode(bytes));
-		},
-		decode(str) {
-			astr("baseN.decode", str);
-			if (str.length > BASE_N_MAX_CHARS) throw new Error("invalid length");
-			return radix.decode(letters.decode(str));
-		}
-	};
-};
-var radix58 = /* @__PURE__ */ radixBaseN(58, B58_GROUP);
-var genBase58 = (abc) => genBaseN(radix58, abc);
-/**
-* base58: base64 without ambigous characters +, /, 0, O, I, l.
-* Quadratic (O(n^2)) - so, can't be used on large inputs.
-* @example
-* ```js
-* const text = base58.encode(Uint8Array.from([0, 1, 2]));
-* base58.decode(text);
-* // => Uint8Array.from([0, 1, 2])
-* ```
-*/
-var base58 = /* @__PURE__ */ freeze(() => genBase58("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"));
-//#endregion
-export { base64urlnopad as i, base64 as n, base64url as r, base58 as t };