salman/igny8
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add yet-another-react-lightbox package and update .gitignore to exclude node_modules

Browse Source
This commit is contained in:
IGNY8 VPS (Salman)
2025-11-12 18:50:30 +00:00
parent bd2a5570a9
commit c92f4a5edd
9304 changed files with 29 additions and 2008667 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
frontend/node_modules/turbo-stream/dist/flatten.d.ts generated vendored
View File

@@ -1,2 +0,0 @@
import { type ThisEncode } from "./utils.js";
export declare function flatten(this: ThisEncode, input: unknown): number | [number];

203
frontend/node_modules/turbo-stream/dist/flatten.js generated vendored
View File

@@ -1,203 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.flatten = void 0;
const utils_js_1 = require("./utils.js");
function flatten(input) {
const { indices } = this;
const existing = indices.get(input);
if (existing)
return [existing];
if (input === undefined)
return utils_js_1.UNDEFINED;
if (input === null)
return utils_js_1.NULL;
if (Number.isNaN(input))
return utils_js_1.NAN;
if (input === Number.POSITIVE_INFINITY)
return utils_js_1.POSITIVE_INFINITY;
if (input === Number.NEGATIVE_INFINITY)
return utils_js_1.NEGATIVE_INFINITY;
if (input === 0 && 1 / input < 0)
return utils_js_1.NEGATIVE_ZERO;
const index = this.index++;
indices.set(input, index);
stringify.call(this, input, index);
return index;
}
exports.flatten = flatten;
function stringify(input, index) {
const { deferred, plugins, postPlugins } = this;
const str = this.stringified;
const stack = [[input, index]];
while (stack.length > 0) {
const [input, index] = stack.pop();
const partsForObj = (obj) => Object.keys(obj)
.map((k) => `"_${flatten.call(this, k)}":${flatten.call(this, obj[k])}`)
.join(",");
let error = null;
switch (typeof input) {
case "boolean":
case "number":
case "string":
str[index] = JSON.stringify(input);
break;
case "bigint":
str[index] = `["${utils_js_1.TYPE_BIGINT}","${input}"]`;
break;
case "symbol": {
const keyFor = Symbol.keyFor(input);
if (!keyFor) {
error = new Error("Cannot encode symbol unless created with Symbol.for()");
}
else {
str[index] = `["${utils_js_1.TYPE_SYMBOL}",${JSON.stringify(keyFor)}]`;
}
break;
}
case "object": {
if (!input) {
str[index] = `${utils_js_1.NULL}`;
break;
}
const isArray = Array.isArray(input);
let pluginHandled = false;
if (!isArray && plugins) {
for (const plugin of plugins) {
const pluginResult = plugin(input);
if (Array.isArray(pluginResult)) {
pluginHandled = true;
const [pluginIdentifier, ...rest] = pluginResult;
str[index] = `[${JSON.stringify(pluginIdentifier)}`;
if (rest.length > 0) {
str[index] += `,${rest
.map((v) => flatten.call(this, v))
.join(",")}`;
}
str[index] += "]";
break;
}
}
}
if (!pluginHandled) {
let result = isArray ? "[" : "{";
if (isArray) {
for (let i = 0; i < input.length; i++)
result +=
(i ? "," : "") +
(i in input ? flatten.call(this, input[i]) : utils_js_1.HOLE);
str[index] = `${result}]`;
}
else if (input instanceof Date) {
str[index] = `["${utils_js_1.TYPE_DATE}",${input.getTime()}]`;
}
else if (input instanceof URL) {
str[index] = `["${utils_js_1.TYPE_URL}",${JSON.stringify(input.href)}]`;
}
else if (input instanceof RegExp) {
str[index] = `["${utils_js_1.TYPE_REGEXP}",${JSON.stringify(input.source)},${JSON.stringify(input.flags)}]`;
}
else if (input instanceof Set) {
if (input.size > 0) {
str[index] = `["${utils_js_1.TYPE_SET}",${[...input]
.map((val) => flatten.call(this, val))
.join(",")}]`;
}
else {
str[index] = `["${utils_js_1.TYPE_SET}"]`;
}
}
else if (input instanceof Map) {
if (input.size > 0) {
str[index] = `["${utils_js_1.TYPE_MAP}",${[...input]
.flatMap(([k, v]) => [
flatten.call(this, k),
flatten.call(this, v),
])
.join(",")}]`;
}
else {
str[index] = `["${utils_js_1.TYPE_MAP}"]`;
}
}
else if (input instanceof Promise) {
str[index] = `["${utils_js_1.TYPE_PROMISE}",${index}]`;
deferred[index] = input;
}
else if (input instanceof Error) {
str[index] = `["${utils_js_1.TYPE_ERROR}",${JSON.stringify(input.message)}`;
if (input.name !== "Error") {
str[index] += `,${JSON.stringify(input.name)}`;
}
str[index] += "]";
}
else if (Object.getPrototypeOf(input) === null) {
str[index] = `["${utils_js_1.TYPE_NULL_OBJECT}",{${partsForObj(input)}}]`;
}
else if (isPlainObject(input)) {
str[index] = `{${partsForObj(input)}}`;
}
else {
error = new Error("Cannot encode object with prototype");
}
}
break;
}
default: {
const isArray = Array.isArray(input);
let pluginHandled = false;
if (!isArray && plugins) {
for (const plugin of plugins) {
const pluginResult = plugin(input);
if (Array.isArray(pluginResult)) {
pluginHandled = true;
const [pluginIdentifier, ...rest] = pluginResult;
str[index] = `[${JSON.stringify(pluginIdentifier)}`;
if (rest.length > 0) {
str[index] += `,${rest
.map((v) => flatten.call(this, v))
.join(",")}`;
}
str[index] += "]";
break;
}
}
}
if (!pluginHandled) {
error = new Error("Cannot encode function or unexpected type");
}
}
}
if (error) {
let pluginHandled = false;
if (postPlugins) {
for (const plugin of postPlugins) {
const pluginResult = plugin(input);
if (Array.isArray(pluginResult)) {
pluginHandled = true;
const [pluginIdentifier, ...rest] = pluginResult;
str[index] = `[${JSON.stringify(pluginIdentifier)}`;
if (rest.length > 0) {
str[index] += `,${rest
.map((v) => flatten.call(this, v))
.join(",")}`;
}
str[index] += "]";
break;
}
}
}
if (!pluginHandled) {
throw error;
}
}
}
}
const objectProtoNames = Object.getOwnPropertyNames(Object.prototype)
.sort()
.join("\0");
function isPlainObject(thing) {
const proto = Object.getPrototypeOf(thing);
return (proto === Object.prototype ||
proto === null ||
Object.getOwnPropertyNames(proto).sort().join("\0") === objectProtoNames);
}

13
frontend/node_modules/turbo-stream/dist/turbo-stream.d.ts generated vendored
View File

@@ -1,13 +0,0 @@
import { type DecodePlugin, type EncodePlugin } from "./utils.js";
export type { DecodePlugin, EncodePlugin };
export declare function decode(readable: ReadableStream<Uint8Array>, options?: {
plugins?: DecodePlugin[];
}): Promise<{
done: Promise<undefined>;
value: unknown;
}>;
export declare function encode(input: unknown, options?: {
plugins?: EncodePlugin[];
postPlugins?: EncodePlugin[];
signal?: AbortSignal;
}): ReadableStream<Uint8Array>;

207
frontend/node_modules/turbo-stream/dist/turbo-stream.js generated vendored
View File

@@ -1,207 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.encode = exports.decode = void 0;
const flatten_js_1 = require("./flatten.js");
const unflatten_js_1 = require("./unflatten.js");
const utils_js_1 = require("./utils.js");
async function decode(readable, options) {
const { plugins } = options ?? {};
const done = new utils_js_1.Deferred();
const reader = readable
.pipeThrough((0, utils_js_1.createLineSplittingTransform)())
.getReader();
const decoder = {
values: [],
hydrated: [],
deferred: {},
plugins,
};
const decoded = await decodeInitial.call(decoder, reader);
let donePromise = done.promise;
if (decoded.done) {
done.resolve();
}
else {
donePromise = decodeDeferred
.call(decoder, reader)
.then(done.resolve)
.catch((reason) => {
for (const deferred of Object.values(decoder.deferred)) {
deferred.reject(reason);
}
done.reject(reason);
});
}
return {
done: donePromise.then(() => reader.closed),
value: decoded.value,
};
}
exports.decode = decode;
async function decodeInitial(reader) {
const read = await reader.read();
if (!read.value) {
throw new SyntaxError();
}
let line;
try {
line = JSON.parse(read.value);
}
catch (reason) {
throw new SyntaxError();
}
return {
done: read.done,
value: unflatten_js_1.unflatten.call(this, line),
};
}
async function decodeDeferred(reader) {
let read = await reader.read();
while (!read.done) {
if (!read.value)
continue;
const line = read.value;
switch (line[0]) {
case utils_js_1.TYPE_PROMISE: {
const colonIndex = line.indexOf(":");
const deferredId = Number(line.slice(1, colonIndex));
const deferred = this.deferred[deferredId];
if (!deferred) {
throw new Error(`Deferred ID ${deferredId} not found in stream`);
}
const lineData = line.slice(colonIndex + 1);
let jsonLine;
try {
jsonLine = JSON.parse(lineData);
}
catch (reason) {
throw new SyntaxError();
}
const value = unflatten_js_1.unflatten.call(this, jsonLine);
deferred.resolve(value);
break;
}
case utils_js_1.TYPE_ERROR: {
const colonIndex = line.indexOf(":");
const deferredId = Number(line.slice(1, colonIndex));
const deferred = this.deferred[deferredId];
if (!deferred) {
throw new Error(`Deferred ID ${deferredId} not found in stream`);
}
const lineData = line.slice(colonIndex + 1);
let jsonLine;
try {
jsonLine = JSON.parse(lineData);
}
catch (reason) {
throw new SyntaxError();
}
const value = unflatten_js_1.unflatten.call(this, jsonLine);
deferred.reject(value);
break;
}
default:
throw new SyntaxError();
}
read = await reader.read();
}
}
function encode(input, options) {
const { plugins, postPlugins, signal } = options ?? {};
const encoder = {
deferred: {},
index: 0,
indices: new Map(),
stringified: [],
plugins,
postPlugins,
signal,
};
const textEncoder = new TextEncoder();
let lastSentIndex = 0;
const readable = new ReadableStream({
async start(controller) {
const id = flatten_js_1.flatten.call(encoder, input);
if (Array.isArray(id)) {
throw new Error("This should never happen");
}
if (id < 0) {
controller.enqueue(textEncoder.encode(`${id}\n`));
}
else {
controller.enqueue(textEncoder.encode(`[${encoder.stringified.join(",")}]\n`));
lastSentIndex = encoder.stringified.length - 1;
}
const seenPromises = new WeakSet();
while (Object.keys(encoder.deferred).length > 0) {
for (const [deferredId, deferred] of Object.entries(encoder.deferred)) {
if (seenPromises.has(deferred))
continue;
seenPromises.add((encoder.deferred[Number(deferredId)] = raceSignal(deferred, encoder.signal)
.then((resolved) => {
const id = flatten_js_1.flatten.call(encoder, resolved);
if (Array.isArray(id)) {
controller.enqueue(textEncoder.encode(`${utils_js_1.TYPE_PROMISE}${deferredId}:[["${utils_js_1.TYPE_PREVIOUS_RESOLVED}",${id[0]}]]\n`));
encoder.index++;
lastSentIndex++;
}
else if (id < 0) {
controller.enqueue(textEncoder.encode(`${utils_js_1.TYPE_PROMISE}${deferredId}:${id}\n`));
}
else {
const values = encoder.stringified
.slice(lastSentIndex + 1)
.join(",");
controller.enqueue(textEncoder.encode(`${utils_js_1.TYPE_PROMISE}${deferredId}:[${values}]\n`));
lastSentIndex = encoder.stringified.length - 1;
}
}, (reason) => {
if (!reason ||
typeof reason !== "object" ||
!(reason instanceof Error)) {
reason = new Error("An unknown error occurred");
}
const id = flatten_js_1.flatten.call(encoder, reason);
if (Array.isArray(id)) {
controller.enqueue(textEncoder.encode(`${utils_js_1.TYPE_ERROR}${deferredId}:[["${utils_js_1.TYPE_PREVIOUS_RESOLVED}",${id[0]}]]\n`));
encoder.index++;
lastSentIndex++;
}
else if (id < 0) {
controller.enqueue(textEncoder.encode(`${utils_js_1.TYPE_ERROR}${deferredId}:${id}\n`));
}
else {
const values = encoder.stringified
.slice(lastSentIndex + 1)
.join(",");
controller.enqueue(textEncoder.encode(`${utils_js_1.TYPE_ERROR}${deferredId}:[${values}]\n`));
lastSentIndex = encoder.stringified.length - 1;
}
})
.finally(() => {
delete encoder.deferred[Number(deferredId)];
})));
}
await Promise.race(Object.values(encoder.deferred));
}
await Promise.all(Object.values(encoder.deferred));
controller.close();
},
});
return readable;
}
exports.encode = encode;
function raceSignal(promise, signal) {
if (!signal)
return promise;
if (signal.aborted)
return Promise.reject(signal.reason || new Error("Signal was aborted."));
const abort = new Promise((resolve, reject) => {
signal.addEventListener("abort", (event) => {
reject(signal.reason || new Error("Signal was aborted."));
});
promise.then(resolve).catch(reject);
});
abort.catch(() => { });
return Promise.race([abort, promise]);
}

673
frontend/node_modules/turbo-stream/dist/turbo-stream.mjs generated vendored
View File

@@ -1,673 +0,0 @@
// src/utils.ts
var HOLE = -1;
var NAN = -2;
var NEGATIVE_INFINITY = -3;
var NEGATIVE_ZERO = -4;
var NULL = -5;
var POSITIVE_INFINITY = -6;
var UNDEFINED = -7;
var TYPE_BIGINT = "B";
var TYPE_DATE = "D";
var TYPE_ERROR = "E";
var TYPE_MAP = "M";
var TYPE_NULL_OBJECT = "N";
var TYPE_PROMISE = "P";
var TYPE_REGEXP = "R";
var TYPE_SET = "S";
var TYPE_SYMBOL = "Y";
var TYPE_URL = "U";
var TYPE_PREVIOUS_RESOLVED = "Z";
var Deferred = class {
promise;
resolve;
reject;
constructor() {
this.promise = new Promise((resolve, reject) => {
this.resolve = resolve;
this.reject = reject;
});
}
};
function createLineSplittingTransform() {
const decoder = new TextDecoder();
let leftover = "";
return new TransformStream({
transform(chunk, controller) {
const str = decoder.decode(chunk, { stream: true });
const parts = (leftover + str).split("\n");
leftover = parts.pop() || "";
for (const part of parts) {
controller.enqueue(part);
}
},
flush(controller) {
if (leftover) {
controller.enqueue(leftover);
}
}
});
}
// src/flatten.ts
function flatten(input) {
const { indices } = this;
const existing = indices.get(input);
if (existing)
return [existing];
if (input === void 0)
return UNDEFINED;
if (input === null)
return NULL;
if (Number.isNaN(input))
return NAN;
if (input === Number.POSITIVE_INFINITY)
return POSITIVE_INFINITY;
if (input === Number.NEGATIVE_INFINITY)
return NEGATIVE_INFINITY;
if (input === 0 && 1 / input < 0)
return NEGATIVE_ZERO;
const index = this.index++;
indices.set(input, index);
stringify.call(this, input, index);
return index;
}
function stringify(input, index) {
const { deferred, plugins, postPlugins } = this;
const str = this.stringified;
const stack = [[input, index]];
while (stack.length > 0) {
const [input2, index2] = stack.pop();
const partsForObj = (obj) => Object.keys(obj).map((k) => `"_${flatten.call(this, k)}":${flatten.call(this, obj[k])}`).join(",");
let error = null;
switch (typeof input2) {
case "boolean":
case "number":
case "string":
str[index2] = JSON.stringify(input2);
break;
case "bigint":
str[index2] = `["${TYPE_BIGINT}","${input2}"]`;
break;
case "symbol": {
const keyFor = Symbol.keyFor(input2);
if (!keyFor) {
error = new Error(
"Cannot encode symbol unless created with Symbol.for()"
);
} else {
str[index2] = `["${TYPE_SYMBOL}",${JSON.stringify(keyFor)}]`;
}
break;
}
case "object": {
if (!input2) {
str[index2] = `${NULL}`;
break;
}
const isArray = Array.isArray(input2);
let pluginHandled = false;
if (!isArray && plugins) {
for (const plugin of plugins) {
const pluginResult = plugin(input2);
if (Array.isArray(pluginResult)) {
pluginHandled = true;
const [pluginIdentifier, ...rest] = pluginResult;
str[index2] = `[${JSON.stringify(pluginIdentifier)}`;
if (rest.length > 0) {
str[index2] += `,${rest.map((v) => flatten.call(this, v)).join(",")}`;
}
str[index2] += "]";
break;
}
}
}
if (!pluginHandled) {
let result = isArray ? "[" : "{";
if (isArray) {
for (let i = 0; i < input2.length; i++)
result += (i ? "," : "") + (i in input2 ? flatten.call(this, input2[i]) : HOLE);
str[index2] = `${result}]`;
} else if (input2 instanceof Date) {
str[index2] = `["${TYPE_DATE}",${input2.getTime()}]`;
} else if (input2 instanceof URL) {
str[index2] = `["${TYPE_URL}",${JSON.stringify(input2.href)}]`;
} else if (input2 instanceof RegExp) {
str[index2] = `["${TYPE_REGEXP}",${JSON.stringify(
input2.source
)},${JSON.stringify(input2.flags)}]`;
} else if (input2 instanceof Set) {
if (input2.size > 0) {
str[index2] = `["${TYPE_SET}",${[...input2].map((val) => flatten.call(this, val)).join(",")}]`;
} else {
str[index2] = `["${TYPE_SET}"]`;
}
} else if (input2 instanceof Map) {
if (input2.size > 0) {
str[index2] = `["${TYPE_MAP}",${[...input2].flatMap(([k, v]) => [
flatten.call(this, k),
flatten.call(this, v)
]).join(",")}]`;
} else {
str[index2] = `["${TYPE_MAP}"]`;
}
} else if (input2 instanceof Promise) {
str[index2] = `["${TYPE_PROMISE}",${index2}]`;
deferred[index2] = input2;
} else if (input2 instanceof Error) {
str[index2] = `["${TYPE_ERROR}",${JSON.stringify(input2.message)}`;
if (input2.name !== "Error") {
str[index2] += `,${JSON.stringify(input2.name)}`;
}
str[index2] += "]";
} else if (Object.getPrototypeOf(input2) === null) {
str[index2] = `["${TYPE_NULL_OBJECT}",{${partsForObj(input2)}}]`;
} else if (isPlainObject(input2)) {
str[index2] = `{${partsForObj(input2)}}`;
} else {
error = new Error("Cannot encode object with prototype");
}
}
break;
}
default: {
const isArray = Array.isArray(input2);
let pluginHandled = false;
if (!isArray && plugins) {
for (const plugin of plugins) {
const pluginResult = plugin(input2);
if (Array.isArray(pluginResult)) {
pluginHandled = true;
const [pluginIdentifier, ...rest] = pluginResult;
str[index2] = `[${JSON.stringify(pluginIdentifier)}`;
if (rest.length > 0) {
str[index2] += `,${rest.map((v) => flatten.call(this, v)).join(",")}`;
}
str[index2] += "]";
break;
}
}
}
if (!pluginHandled) {
error = new Error("Cannot encode function or unexpected type");
}
}
}
if (error) {
let pluginHandled = false;
if (postPlugins) {
for (const plugin of postPlugins) {
const pluginResult = plugin(input2);
if (Array.isArray(pluginResult)) {
pluginHandled = true;
const [pluginIdentifier, ...rest] = pluginResult;
str[index2] = `[${JSON.stringify(pluginIdentifier)}`;
if (rest.length > 0) {
str[index2] += `,${rest.map((v) => flatten.call(this, v)).join(",")}`;
}
str[index2] += "]";
break;
}
}
}
if (!pluginHandled) {
throw error;
}
}
}
}
var objectProtoNames = Object.getOwnPropertyNames(Object.prototype).sort().join("\0");
function isPlainObject(thing) {
const proto = Object.getPrototypeOf(thing);
return proto === Object.prototype || proto === null || Object.getOwnPropertyNames(proto).sort().join("\0") === objectProtoNames;
}
// src/unflatten.ts
var globalObj = typeof window !== "undefined" ? window : typeof globalThis !== "undefined" ? globalThis : void 0;
function unflatten(parsed) {
const { hydrated, values } = this;
if (typeof parsed === "number")
return hydrate.call(this, parsed);
if (!Array.isArray(parsed) || !parsed.length)
throw new SyntaxError();
const startIndex = values.length;
for (const value of parsed) {
values.push(value);
}
hydrated.length = values.length;
return hydrate.call(this, startIndex);
}
function hydrate(index) {
const { hydrated, values, deferred, plugins } = this;
let result;
const stack = [
[
index,
(v) => {
result = v;
}
]
];
let postRun = [];
while (stack.length > 0) {
const [index2, set] = stack.pop();
switch (index2) {
case UNDEFINED:
set(void 0);
continue;
case NULL:
set(null);
continue;
case NAN:
set(NaN);
continue;
case POSITIVE_INFINITY:
set(Infinity);
continue;
case NEGATIVE_INFINITY:
set(-Infinity);
continue;
case NEGATIVE_ZERO:
set(-0);
continue;
}
if (hydrated[index2]) {
set(hydrated[index2]);
continue;
}
const value = values[index2];
if (!value || typeof value !== "object") {
hydrated[index2] = value;
set(value);
continue;
}
if (Array.isArray(value)) {
if (typeof value[0] === "string") {
const [type, b, c] = value;
switch (type) {
case TYPE_DATE:
set(hydrated[index2] = new Date(b));
continue;
case TYPE_URL:
set(hydrated[index2] = new URL(b));
continue;
case TYPE_BIGINT:
set(hydrated[index2] = BigInt(b));
continue;
case TYPE_REGEXP:
set(hydrated[index2] = new RegExp(b, c));
continue;
case TYPE_SYMBOL:
set(hydrated[index2] = Symbol.for(b));
continue;
case TYPE_SET:
const newSet = /* @__PURE__ */ new Set();
hydrated[index2] = newSet;
for (let i = 1; i < value.length; i++)
stack.push([
value[i],
(v) => {
newSet.add(v);
}
]);
set(newSet);
continue;
case TYPE_MAP:
const map = /* @__PURE__ */ new Map();
hydrated[index2] = map;
for (let i = 1; i < value.length; i += 2) {
const r = [];
stack.push([
value[i + 1],
(v) => {
r[1] = v;
}
]);
stack.push([
value[i],
(k) => {
r[0] = k;
}
]);
postRun.push(() => {
map.set(r[0], r[1]);
});
}
set(map);
continue;
case TYPE_NULL_OBJECT:
const obj = /* @__PURE__ */ Object.create(null);
hydrated[index2] = obj;
for (const key of Object.keys(b).reverse()) {
const r = [];
stack.push([
b[key],
(v) => {
r[1] = v;
}
]);
stack.push([
Number(key.slice(1)),
(k) => {
r[0] = k;
}
]);
postRun.push(() => {
obj[r[0]] = r[1];
});
}
set(obj);
continue;
case TYPE_PROMISE:
if (hydrated[b]) {
set(hydrated[index2] = hydrated[b]);
} else {
const d = new Deferred();
deferred[b] = d;
set(hydrated[index2] = d.promise);
}
continue;
case TYPE_ERROR:
const [, message, errorType] = value;
let error = errorType && globalObj && globalObj[errorType] ? new globalObj[errorType](message) : new Error(message);
hydrated[index2] = error;
set(error);
continue;
case TYPE_PREVIOUS_RESOLVED:
set(hydrated[index2] = hydrated[b]);
continue;
default:
if (Array.isArray(plugins)) {
const r = [];
const vals = value.slice(1);
for (let i = 0; i < vals.length; i++) {
const v = vals[i];
stack.push([
v,
(v2) => {
r[i] = v2;
}
]);
}
postRun.push(() => {
for (const plugin of plugins) {
const result2 = plugin(value[0], ...r);
if (result2) {
set(hydrated[index2] = result2.value);
return;
}
}
throw new SyntaxError();
});
continue;
}
throw new SyntaxError();
}
} else {
const array = [];
hydrated[index2] = array;
for (let i = 0; i < value.length; i++) {
const n = value[i];
if (n !== HOLE) {
stack.push([
n,
(v) => {
array[i] = v;
}
]);
}
}
set(array);
continue;
}
} else {
const object = {};
hydrated[index2] = object;
for (const key of Object.keys(value).reverse()) {
const r = [];
stack.push([
value[key],
(v) => {
r[1] = v;
}
]);
stack.push([
Number(key.slice(1)),
(k) => {
r[0] = k;
}
]);
postRun.push(() => {
object[r[0]] = r[1];
});
}
set(object);
continue;
}
}
while (postRun.length > 0) {
postRun.pop()();
}
return result;
}
// src/turbo-stream.ts
async function decode(readable, options) {
const { plugins } = options ?? {};
const done = new Deferred();
const reader = readable.pipeThrough(createLineSplittingTransform()).getReader();
const decoder = {
values: [],
hydrated: [],
deferred: {},
plugins
};
const decoded = await decodeInitial.call(decoder, reader);
let donePromise = done.promise;
if (decoded.done) {
done.resolve();
} else {
donePromise = decodeDeferred.call(decoder, reader).then(done.resolve).catch((reason) => {
for (const deferred of Object.values(decoder.deferred)) {
deferred.reject(reason);
}
done.reject(reason);
});
}
return {
done: donePromise.then(() => reader.closed),
value: decoded.value
};
}
async function decodeInitial(reader) {
const read = await reader.read();
if (!read.value) {
throw new SyntaxError();
}
let line;
try {
line = JSON.parse(read.value);
} catch (reason) {
throw new SyntaxError();
}
return {
done: read.done,
value: unflatten.call(this, line)
};
}
async function decodeDeferred(reader) {
let read = await reader.read();
while (!read.done) {
if (!read.value)
continue;
const line = read.value;
switch (line[0]) {
case TYPE_PROMISE: {
const colonIndex = line.indexOf(":");
const deferredId = Number(line.slice(1, colonIndex));
const deferred = this.deferred[deferredId];
if (!deferred) {
throw new Error(`Deferred ID ${deferredId} not found in stream`);
}
const lineData = line.slice(colonIndex + 1);
let jsonLine;
try {
jsonLine = JSON.parse(lineData);
} catch (reason) {
throw new SyntaxError();
}
const value = unflatten.call(this, jsonLine);
deferred.resolve(value);
break;
}
case TYPE_ERROR: {
const colonIndex = line.indexOf(":");
const deferredId = Number(line.slice(1, colonIndex));
const deferred = this.deferred[deferredId];
if (!deferred) {
throw new Error(`Deferred ID ${deferredId} not found in stream`);
}
const lineData = line.slice(colonIndex + 1);
let jsonLine;
try {
jsonLine = JSON.parse(lineData);
} catch (reason) {
throw new SyntaxError();
}
const value = unflatten.call(this, jsonLine);
deferred.reject(value);
break;
}
default:
throw new SyntaxError();
}
read = await reader.read();
}
}
function encode(input, options) {
const { plugins, postPlugins, signal } = options ?? {};
const encoder = {
deferred: {},
index: 0,
indices: /* @__PURE__ */ new Map(),
stringified: [],
plugins,
postPlugins,
signal
};
const textEncoder = new TextEncoder();
let lastSentIndex = 0;
const readable = new ReadableStream({
async start(controller) {
const id = flatten.call(encoder, input);
if (Array.isArray(id)) {
throw new Error("This should never happen");
}
if (id < 0) {
controller.enqueue(textEncoder.encode(`${id}
`));
} else {
controller.enqueue(
textEncoder.encode(`[${encoder.stringified.join(",")}]
`)
);
lastSentIndex = encoder.stringified.length - 1;
}
const seenPromises = /* @__PURE__ */ new WeakSet();
while (Object.keys(encoder.deferred).length > 0) {
for (const [deferredId, deferred] of Object.entries(encoder.deferred)) {
if (seenPromises.has(deferred))
continue;
seenPromises.add(
encoder.deferred[Number(deferredId)] = raceSignal(
deferred,
encoder.signal
).then(
(resolved) => {
const id2 = flatten.call(encoder, resolved);
if (Array.isArray(id2)) {
controller.enqueue(
textEncoder.encode(
`${TYPE_PROMISE}${deferredId}:[["${TYPE_PREVIOUS_RESOLVED}",${id2[0]}]]
`
)
);
encoder.index++;
lastSentIndex++;
} else if (id2 < 0) {
controller.enqueue(
textEncoder.encode(`${TYPE_PROMISE}${deferredId}:${id2}
`)
);
} else {
const values = encoder.stringified.slice(lastSentIndex + 1).join(",");
controller.enqueue(
textEncoder.encode(
`${TYPE_PROMISE}${deferredId}:[${values}]
`
)
);
lastSentIndex = encoder.stringified.length - 1;
}
},
(reason) => {
if (!reason || typeof reason !== "object" || !(reason instanceof Error)) {
reason = new Error("An unknown error occurred");
}
const id2 = flatten.call(encoder, reason);
if (Array.isArray(id2)) {
controller.enqueue(
textEncoder.encode(
`${TYPE_ERROR}${deferredId}:[["${TYPE_PREVIOUS_RESOLVED}",${id2[0]}]]
`
)
);
encoder.index++;
lastSentIndex++;
} else if (id2 < 0) {
controller.enqueue(
textEncoder.encode(`${TYPE_ERROR}${deferredId}:${id2}
`)
);
} else {
const values = encoder.stringified.slice(lastSentIndex + 1).join(",");
controller.enqueue(
textEncoder.encode(
`${TYPE_ERROR}${deferredId}:[${values}]
`
)
);
lastSentIndex = encoder.stringified.length - 1;
}
}
).finally(() => {
delete encoder.deferred[Number(deferredId)];
})
);
}
await Promise.race(Object.values(encoder.deferred));
}
await Promise.all(Object.values(encoder.deferred));
controller.close();
}
});
return readable;
}
function raceSignal(promise, signal) {
if (!signal)
return promise;
if (signal.aborted)
return Promise.reject(signal.reason || new Error("Signal was aborted."));
const abort = new Promise((resolve, reject) => {
signal.addEventListener("abort", (event) => {
reject(signal.reason || new Error("Signal was aborted."));
});
promise.then(resolve).catch(reject);
});
abort.catch(() => {
});
return Promise.race([abort, promise]);
}
export {
decode,
encode
};

2
frontend/node_modules/turbo-stream/dist/unflatten.d.ts generated vendored
View File

@@ -1,2 +0,0 @@
import { type ThisDecode } from "./utils.js";
export declare function unflatten(this: ThisDecode, parsed: unknown): unknown;

243
frontend/node_modules/turbo-stream/dist/unflatten.js generated vendored
View File

@@ -1,243 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.unflatten = void 0;
const utils_js_1 = require("./utils.js");
const globalObj = (typeof window !== "undefined"
? window
: typeof globalThis !== "undefined"
? globalThis
: undefined);
function unflatten(parsed) {
const { hydrated, values } = this;
if (typeof parsed === "number")
return hydrate.call(this, parsed);
if (!Array.isArray(parsed) || !parsed.length)
throw new SyntaxError();
const startIndex = values.length;
for (const value of parsed) {
values.push(value);
}
hydrated.length = values.length;
return hydrate.call(this, startIndex);
}
exports.unflatten = unflatten;
function hydrate(index) {
const { hydrated, values, deferred, plugins } = this;
let result;
const stack = [
[
index,
(v) => {
result = v;
},
],
];
let postRun = [];
while (stack.length > 0) {
const [index, set] = stack.pop();
switch (index) {
case utils_js_1.UNDEFINED:
set(undefined);
continue;
case utils_js_1.NULL:
set(null);
continue;
case utils_js_1.NAN:
set(NaN);
continue;
case utils_js_1.POSITIVE_INFINITY:
set(Infinity);
continue;
case utils_js_1.NEGATIVE_INFINITY:
set(-Infinity);
continue;
case utils_js_1.NEGATIVE_ZERO:
set(-0);
continue;
}
if (hydrated[index]) {
set(hydrated[index]);
continue;
}
const value = values[index];
if (!value || typeof value !== "object") {
hydrated[index] = value;
set(value);
continue;
}
if (Array.isArray(value)) {
if (typeof value[0] === "string") {
const [type, b, c] = value;
switch (type) {
case utils_js_1.TYPE_DATE:
set((hydrated[index] = new Date(b)));
continue;
case utils_js_1.TYPE_URL:
set((hydrated[index] = new URL(b)));
continue;
case utils_js_1.TYPE_BIGINT:
set((hydrated[index] = BigInt(b)));
continue;
case utils_js_1.TYPE_REGEXP:
set((hydrated[index] = new RegExp(b, c)));
continue;
case utils_js_1.TYPE_SYMBOL:
set((hydrated[index] = Symbol.for(b)));
continue;
case utils_js_1.TYPE_SET:
const newSet = new Set();
hydrated[index] = newSet;
for (let i = 1; i < value.length; i++)
stack.push([
value[i],
(v) => {
newSet.add(v);
},
]);
set(newSet);
continue;
case utils_js_1.TYPE_MAP:
const map = new Map();
hydrated[index] = map;
for (let i = 1; i < value.length; i += 2) {
const r = [];
stack.push([
value[i + 1],
(v) => {
r[1] = v;
},
]);
stack.push([
value[i],
(k) => {
r[0] = k;
},
]);
postRun.push(() => {
map.set(r[0], r[1]);
});
}
set(map);
continue;
case utils_js_1.TYPE_NULL_OBJECT:
const obj = Object.create(null);
hydrated[index] = obj;
for (const key of Object.keys(b).reverse()) {
const r = [];
stack.push([
b[key],
(v) => {
r[1] = v;
},
]);
stack.push([
Number(key.slice(1)),
(k) => {
r[0] = k;
},
]);
postRun.push(() => {
obj[r[0]] = r[1];
});
}
set(obj);
continue;
case utils_js_1.TYPE_PROMISE:
if (hydrated[b]) {
set((hydrated[index] = hydrated[b]));
}
else {
const d = new utils_js_1.Deferred();
deferred[b] = d;
set((hydrated[index] = d.promise));
}
continue;
case utils_js_1.TYPE_ERROR:
const [, message, errorType] = value;
let error = errorType && globalObj && globalObj[errorType]
? new globalObj[errorType](message)
: new Error(message);
hydrated[index] = error;
set(error);
continue;
case utils_js_1.TYPE_PREVIOUS_RESOLVED:
set((hydrated[index] = hydrated[b]));
continue;
default:
// Run plugins at the end so we have a chance to resolve primitives
// without running into a loop
if (Array.isArray(plugins)) {
const r = [];
const vals = value.slice(1);
for (let i = 0; i < vals.length; i++) {
const v = vals[i];
stack.push([
v,
(v) => {
r[i] = v;
},
]);
}
postRun.push(() => {
for (const plugin of plugins) {
const result = plugin(value[0], ...r);
if (result) {
set((hydrated[index] = result.value));
return;
}
}
throw new SyntaxError();
});
continue;
}
throw new SyntaxError();
}
}
else {
const array = [];
hydrated[index] = array;
for (let i = 0; i < value.length; i++) {
const n = value[i];
if (n !== utils_js_1.HOLE) {
stack.push([
n,
(v) => {
array[i] = v;
},
]);
}
}
set(array);
continue;
}
}
else {
const object = {};
hydrated[index] = object;
for (const key of Object.keys(value).reverse()) {
const r = [];
stack.push([
value[key],
(v) => {
r[1] = v;
},
]);
stack.push([
Number(key.slice(1)),
(k) => {
r[0] = k;
},
]);
postRun.push(() => {
object[r[0]] = r[1];
});
}
set(object);
continue;
}
}
while (postRun.length > 0) {
postRun.pop()();
}
return result;
}

44
frontend/node_modules/turbo-stream/dist/utils.d.ts generated vendored
View File

@@ -1,44 +0,0 @@
export declare const HOLE = -1;
export declare const NAN = -2;
export declare const NEGATIVE_INFINITY = -3;
export declare const NEGATIVE_ZERO = -4;
export declare const NULL = -5;
export declare const POSITIVE_INFINITY = -6;
export declare const UNDEFINED = -7;
export declare const TYPE_BIGINT = "B";
export declare const TYPE_DATE = "D";
export declare const TYPE_ERROR = "E";
export declare const TYPE_MAP = "M";
export declare const TYPE_NULL_OBJECT = "N";
export declare const TYPE_PROMISE = "P";
export declare const TYPE_REGEXP = "R";
export declare const TYPE_SET = "S";
export declare const TYPE_SYMBOL = "Y";
export declare const TYPE_URL = "U";
export declare const TYPE_PREVIOUS_RESOLVED = "Z";
export type DecodePlugin = (type: string, ...data: unknown[]) => {
value: unknown;
} | false | null | undefined;
export type EncodePlugin = (value: unknown) => [string, ...unknown[]] | false | null | undefined;
export interface ThisDecode {
values: unknown[];
hydrated: unknown[];
deferred: Record<number, Deferred<unknown>>;
plugins?: DecodePlugin[];
}
export interface ThisEncode {
index: number;
indices: Map<unknown, number>;
stringified: string[];
deferred: Record<number, Promise<unknown>>;
plugins?: EncodePlugin[];
postPlugins?: EncodePlugin[];
signal?: AbortSignal;
}
export declare class Deferred<T = unknown> {
promise: Promise<T>;
resolve: (value: T) => void;
reject: (reason: unknown) => void;
constructor();
}
export declare function createLineSplittingTransform(): TransformStream<any, any>;

55
frontend/node_modules/turbo-stream/dist/utils.js generated vendored
View File

@@ -1,55 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.createLineSplittingTransform = exports.Deferred = exports.TYPE_PREVIOUS_RESOLVED = exports.TYPE_URL = exports.TYPE_SYMBOL = exports.TYPE_SET = exports.TYPE_REGEXP = exports.TYPE_PROMISE = exports.TYPE_NULL_OBJECT = exports.TYPE_MAP = exports.TYPE_ERROR = exports.TYPE_DATE = exports.TYPE_BIGINT = exports.UNDEFINED = exports.POSITIVE_INFINITY = exports.NULL = exports.NEGATIVE_ZERO = exports.NEGATIVE_INFINITY = exports.NAN = exports.HOLE = void 0;
exports.HOLE = -1;
exports.NAN = -2;
exports.NEGATIVE_INFINITY = -3;
exports.NEGATIVE_ZERO = -4;
exports.NULL = -5;
exports.POSITIVE_INFINITY = -6;
exports.UNDEFINED = -7;
exports.TYPE_BIGINT = "B";
exports.TYPE_DATE = "D";
exports.TYPE_ERROR = "E";
exports.TYPE_MAP = "M";
exports.TYPE_NULL_OBJECT = "N";
exports.TYPE_PROMISE = "P";
exports.TYPE_REGEXP = "R";
exports.TYPE_SET = "S";
exports.TYPE_SYMBOL = "Y";
exports.TYPE_URL = "U";
exports.TYPE_PREVIOUS_RESOLVED = "Z";
class Deferred {
promise;
resolve;
reject;
constructor() {
this.promise = new Promise((resolve, reject) => {
this.resolve = resolve;
this.reject = reject;
});
}
}
exports.Deferred = Deferred;
function createLineSplittingTransform() {
const decoder = new TextDecoder();
let leftover = "";
return new TransformStream({
transform(chunk, controller) {
const str = decoder.decode(chunk, { stream: true });
const parts = (leftover + str).split("\n");
// The last part might be a partial line, so keep it for the next chunk.
leftover = parts.pop() || "";
for (const part of parts) {
controller.enqueue(part);
}
},
flush(controller) {
// If there's any leftover data, enqueue it before closing.
if (leftover) {
controller.enqueue(leftover);
}
},
});
}
exports.createLineSplittingTransform = createLineSplittingTransform;