@epic-web/workshop-app 4.0.0

package/node_modules/@remix-run/server-runtime/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@remix-run/server-runtime",
+  "version": "2.8.1",
+  "description": "Server runtime for Remix",
+  "bugs": {
+    "url": "https://github.com/remix-run/remix/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/remix-run/remix",
+    "directory": "packages/remix-server-runtime"
+  },
+  "license": "MIT",
+  "sideEffects": false,
+  "main": "dist/index.js",
+  "typings": "dist/index.d.ts",
+  "module": "dist/esm/index.js",
+  "dependencies": {
+    "@remix-run/router": "1.15.3",
+    "@types/cookie": "^0.6.0",
+    "@web3-storage/multipart-parser": "^1.0.0",
+    "cookie": "^0.6.0",
+    "set-cookie-parser": "^2.4.8",
+    "source-map": "^0.7.3"
+  },
+  "devDependencies": {
+    "@types/set-cookie-parser": "^2.4.1",
+    "typescript": "^5.1.6"
+  },
+  "peerDependencies": {
+    "typescript": "^5.1.0"
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "dist/",
+    "CHANGELOG.md",
+    "LICENSE.md",
+    "README.md"
+  ]
+}

package/node_modules/@types/cookie/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

package/node_modules/@types/cookie/README.md

@@ -0,0 +1,15 @@
+# Installation
+> `npm install --save @types/cookie`
+
+# Summary
+This package contains type definitions for cookie (https://github.com/jshttp/cookie).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/cookie.
+
+### Additional Details
+ * Last updated: Sun, 26 Nov 2023 22:07:01 GMT
+ * Dependencies: none
+
+# Credits
+These definitions were written by [Pine Mizune](https://github.com/pine), and [Piotr Błażejewicz](https://github.com/peterblazejewicz).

package/node_modules/@types/cookie/index.d.ts

@@ -0,0 +1,154 @@
+/**
+ * Basic HTTP cookie parser and serializer for HTTP servers.
+ */
+
+/**
+ * Additional serialization options
+ */
+export interface CookieSerializeOptions {
+    /**
+     * Specifies the value for the {@link https://tools.ietf.org/html/rfc6265#section-5.2.3|Domain Set-Cookie attribute}. By default, no
+     * domain is set, and most clients will consider the cookie to apply to only
+     * the current domain.
+     */
+    domain?: string | undefined;
+
+    /**
+     * Specifies a function that will be used to encode a cookie's value. Since
+     * value of a cookie has a limited character set (and must be a simple
+     * string), this function can be used to encode a value into a string suited
+     * for a cookie's value.
+     *
+     * The default function is the global `encodeURIComponent`, which will
+     * encode a JavaScript string into UTF-8 byte sequences and then URL-encode
+     * any that fall outside of the cookie range.
+     */
+    encode?(value: string): string;
+
+    /**
+     * Specifies the `Date` object to be the value for the {@link https://tools.ietf.org/html/rfc6265#section-5.2.1|`Expires` `Set-Cookie` attribute}. By default,
+     * no expiration is set, and most clients will consider this a "non-persistent cookie" and will delete
+     * it on a condition like exiting a web browser application.
+     *
+     * *Note* the {@link https://tools.ietf.org/html/rfc6265#section-5.3|cookie storage model specification}
+     * states that if both `expires` and `maxAge` are set, then `maxAge` takes precedence, but it is
+     * possible not all clients by obey this, so if both are set, they should
+     * point to the same date and time.
+     */
+    expires?: Date | undefined;
+    /**
+     * Specifies the boolean value for the {@link https://tools.ietf.org/html/rfc6265#section-5.2.6|`HttpOnly` `Set-Cookie` attribute}.
+     * When truthy, the `HttpOnly` attribute is set, otherwise it is not. By
+     * default, the `HttpOnly` attribute is not set.
+     *
+     * *Note* be careful when setting this to true, as compliant clients will
+     * not allow client-side JavaScript to see the cookie in `document.cookie`.
+     */
+    httpOnly?: boolean | undefined;
+    /**
+     * Specifies the number (in seconds) to be the value for the `Max-Age`
+     * `Set-Cookie` attribute. The given number will be converted to an integer
+     * by rounding down. By default, no maximum age is set.
+     *
+     * *Note* the {@link https://tools.ietf.org/html/rfc6265#section-5.3|cookie storage model specification}
+     * states that if both `expires` and `maxAge` are set, then `maxAge` takes precedence, but it is
+     * possible not all clients by obey this, so if both are set, they should
+     * point to the same date and time.
+     */
+    maxAge?: number | undefined;
+    /**
+     * Specifies the `boolean` value for the [`Partitioned` `Set-Cookie`](rfc-cutler-httpbis-partitioned-cookies)
+     * attribute. When truthy, the `Partitioned` attribute is set, otherwise it is not. By default, the
+     * `Partitioned` attribute is not set.
+     *
+     * **note** This is an attribute that has not yet been fully standardized, and may change in the future.
+     * This also means many clients may ignore this attribute until they understand it.
+     *
+     * More information about can be found in [the proposal](https://github.com/privacycg/CHIPS)
+     */
+    partitioned?: boolean | undefined;
+    /**
+     * Specifies the value for the {@link https://tools.ietf.org/html/rfc6265#section-5.2.4|`Path` `Set-Cookie` attribute}.
+     * By default, the path is considered the "default path".
+     */
+    path?: string | undefined;
+    /**
+     * Specifies the `string` to be the value for the [`Priority` `Set-Cookie` attribute][rfc-west-cookie-priority-00-4.1].
+     *
+     * - `'low'` will set the `Priority` attribute to `Low`.
+     * - `'medium'` will set the `Priority` attribute to `Medium`, the default priority when not set.
+     * - `'high'` will set the `Priority` attribute to `High`.
+     *
+     * More information about the different priority levels can be found in
+     * [the specification][rfc-west-cookie-priority-00-4.1].
+     *
+     * **note** This is an attribute that has not yet been fully standardized, and may change in the future.
+     * This also means many clients may ignore this attribute until they understand it.
+     */
+    priority?: "low" | "medium" | "high" | undefined;
+    /**
+     * Specifies the boolean or string to be the value for the {@link https://tools.ietf.org/html/draft-ietf-httpbis-rfc6265bis-03#section-4.1.2.7|`SameSite` `Set-Cookie` attribute}.
+     *
+     * - `true` will set the `SameSite` attribute to `Strict` for strict same
+     * site enforcement.
+     * - `false` will not set the `SameSite` attribute.
+     * - `'lax'` will set the `SameSite` attribute to Lax for lax same site
+     * enforcement.
+     * - `'strict'` will set the `SameSite` attribute to Strict for strict same
+     * site enforcement.
+     *  - `'none'` will set the SameSite attribute to None for an explicit
+     *  cross-site cookie.
+     *
+     * More information about the different enforcement levels can be found in {@link https://tools.ietf.org/html/draft-ietf-httpbis-rfc6265bis-03#section-4.1.2.7|the specification}.
+     *
+     * *note* This is an attribute that has not yet been fully standardized, and may change in the future. This also means many clients may ignore this attribute until they understand it.
+     */
+    sameSite?: true | false | "lax" | "strict" | "none" | undefined;
+    /**
+     * Specifies the boolean value for the {@link https://tools.ietf.org/html/rfc6265#section-5.2.5|`Secure` `Set-Cookie` attribute}. When truthy, the
+     * `Secure` attribute is set, otherwise it is not. By default, the `Secure` attribute is not set.
+     *
+     * *Note* be careful when setting this to `true`, as compliant clients will
+     * not send the cookie back to the server in the future if the browser does
+     * not have an HTTPS connection.
+     */
+    secure?: boolean | undefined;
+}
+
+/**
+ * Additional parsing options
+ */
+export interface CookieParseOptions {
+    /**
+     * Specifies a function that will be used to decode a cookie's value. Since
+     * the value of a cookie has a limited character set (and must be a simple
+     * string), this function can be used to decode a previously-encoded cookie
+     * value into a JavaScript string or other object.
+     *
+     * The default function is the global `decodeURIComponent`, which will decode
+     * any URL-encoded sequences into their byte representations.
+     *
+     * *Note* if an error is thrown from this function, the original, non-decoded
+     * cookie value will be returned as the cookie's value.
+     */
+    decode?(value: string): string;
+}
+
+/**
+ * Parse an HTTP Cookie header string and returning an object of all cookie
+ * name-value pairs.
+ *
+ * @param str the string representing a `Cookie` header value
+ * @param [options] object containing parsing options
+ */
+export function parse(str: string, options?: CookieParseOptions): Record<string, string>;
+
+/**
+ * Serialize a cookie name-value pair into a `Set-Cookie` header string.
+ *
+ * @param name the name for the cookie
+ * @param value value to set the cookie to
+ * @param [options] object containing serialization options
+ * @throws {TypeError} when `maxAge` options is invalid
+ */
+export function serialize(name: string, value: string, options?: CookieSerializeOptions): string;

package/node_modules/@types/cookie/package.json

@@ -0,0 +1,30 @@
+{
+    "name": "@types/cookie",
+    "version": "0.6.0",
+    "description": "TypeScript definitions for cookie",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/cookie",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "Pine Mizune",
+            "githubUsername": "pine",
+            "url": "https://github.com/pine"
+        },
+        {
+            "name": "Piotr Błażejewicz",
+            "githubUsername": "peterblazejewicz",
+            "url": "https://github.com/peterblazejewicz"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/cookie"
+    },
+    "scripts": {},
+    "dependencies": {},
+    "typesPublisherContentHash": "0fbdf9c886fb40c8dc7677b8b7d0f9e02ac5235e163d90244a4fb9004736a575",
+    "typeScriptVersion": "4.5"
+}

package/node_modules/@web3-storage/multipart-parser/README.md

@@ -0,0 +1,37 @@
+# multipart-parser
+
+> A simple multipart/form-data parser to use with ReadableStreams
+
+Based on https://github.com/ssttevee/js-multipart-parser
+
+## Install
+
+```sh
+# install it as a dependency
+$ npm i @web3-storage/multipart-parser
+```
+
+# Usage
+
+```js
+import { parseMultipart } from '@web3-storage/multipart-parser';
+
+...
+
+async function requestHandler(req) {
+    const boundary = '----whatever';
+    const parts = await parseMultipart(req.body, boundary);
+    const fd = new FormData();
+    for (const { name, data, filename, contentType } of parts) {
+        if (filename) {
+            fd.append(name, new Blob([data], { type: contentType }), filename);
+        } else {
+            fd.append(name, new TextDecoder().decode(data), filename);
+        }
+    }
+}
+```
+
+## Releasing
+
+You can publish by either running npm publish in the dist directory or using npx ipjs publish.

package/node_modules/@web3-storage/multipart-parser/cjs/src/index.js

@@ -0,0 +1,218 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var search = require('./search.js');
+var utils = require('./utils.js');
+
+const mergeArrays2 = Function.prototype.apply.bind(utils.mergeArrays, undefined);
+const dash = utils.stringToArray('--');
+const CRLF = utils.stringToArray('\r\n');
+function parseContentDisposition(header) {
+  const parts = header.split(';').map(part => part.trim());
+  if (parts.shift() !== 'form-data') {
+    throw new Error('malformed content-disposition header: missing "form-data" in `' + JSON.stringify(parts) + '`');
+  }
+  const out = {};
+  for (const part of parts) {
+    const kv = part.split('=', 2);
+    if (kv.length !== 2) {
+      throw new Error('malformed content-disposition header: key-value pair not found - ' + part + ' in `' + header + '`');
+    }
+    const [name, value] = kv;
+    if (value[0] === '"' && value[value.length - 1] === '"') {
+      out[name] = value.slice(1, -1).replace(/\\"/g, '"');
+    } else if (value[0] !== '"' && value[value.length - 1] !== '"') {
+      out[name] = value;
+    } else if (value[0] === '"' && value[value.length - 1] !== '"' || value[0] !== '"' && value[value.length - 1] === '"') {
+      throw new Error('malformed content-disposition header: mismatched quotations in `' + header + '`');
+    }
+  }
+  if (!out.name) {
+    throw new Error('malformed content-disposition header: missing field name in `' + header + '`');
+  }
+  return out;
+}
+function parsePartHeaders(lines) {
+  const entries = [];
+  let disposition = false;
+  let line;
+  while (typeof (line = lines.shift()) !== 'undefined') {
+    const colon = line.indexOf(':');
+    if (colon === -1) {
+      throw new Error('malformed multipart-form header: missing colon');
+    }
+    const header = line.slice(0, colon).trim().toLowerCase();
+    const value = line.slice(colon + 1).trim();
+    switch (header) {
+    case 'content-disposition':
+      disposition = true;
+      entries.push(...Object.entries(parseContentDisposition(value)));
+      break;
+    case 'content-type':
+      entries.push([
+        'contentType',
+        value
+      ]);
+    }
+  }
+  if (!disposition) {
+    throw new Error('malformed multipart-form header: missing content-disposition');
+  }
+  return Object.fromEntries(entries);
+}
+async function readHeaderLines(it, needle) {
+  let firstChunk = true;
+  let lastTokenWasMatch = false;
+  const headerLines = [[]];
+  const crlfSearch = new search.StreamSearch(CRLF);
+  for (;;) {
+    const result = await it.next();
+    if (result.done) {
+      throw new Error('malformed multipart-form data: unexpected end of stream');
+    }
+    if (firstChunk && result.value !== search.MATCH && utils.arraysEqual(result.value.slice(0, 2), dash)) {
+      return [
+        undefined,
+        new Uint8Array()
+      ];
+    }
+    let chunk;
+    if (result.value !== search.MATCH) {
+      chunk = result.value;
+    } else if (!lastTokenWasMatch) {
+      chunk = needle;
+    } else {
+      throw new Error('malformed multipart-form data: unexpected boundary');
+    }
+    if (!chunk.length) {
+      continue;
+    }
+    if (firstChunk) {
+      firstChunk = false;
+    }
+    const tokens = crlfSearch.feed(chunk);
+    for (const [i, token] of tokens.entries()) {
+      const isMatch = token === search.MATCH;
+      if (!isMatch && !token.length) {
+        continue;
+      }
+      if (lastTokenWasMatch && isMatch) {
+        tokens.push(crlfSearch.end());
+        return [
+          headerLines.filter(chunks => chunks.length).map(mergeArrays2).map(utils.arrayToString),
+          utils.mergeArrays(...tokens.slice(i + 1).map(token => token === search.MATCH ? CRLF : token))
+        ];
+      }
+      if (lastTokenWasMatch = isMatch) {
+        headerLines.push([]);
+      } else {
+        headerLines[headerLines.length - 1].push(token);
+      }
+    }
+  }
+}
+async function* streamMultipart(body, boundary) {
+  const needle = utils.mergeArrays(dash, utils.stringToArray(boundary));
+  const it = new search.ReadableStreamSearch(needle, body)[Symbol.asyncIterator]();
+  for (;;) {
+    const result = await it.next();
+    if (result.done) {
+      return;
+    }
+    if (result.value === search.MATCH) {
+      break;
+    }
+  }
+  const crlfSearch = new search.StreamSearch(CRLF);
+  for (;;) {
+    const [headerLines, tail] = await readHeaderLines(it, needle);
+    if (!headerLines) {
+      return;
+    }
+    async function nextToken() {
+      const result = await it.next();
+      if (result.done) {
+        throw new Error('malformed multipart-form data: unexpected end of stream');
+      }
+      return result;
+    }
+    let trailingCRLF = false;
+    function feedChunk(chunk) {
+      const chunks = [];
+      for (const token of crlfSearch.feed(chunk)) {
+        if (trailingCRLF) {
+          chunks.push(CRLF);
+        }
+        if (!(trailingCRLF = token === search.MATCH)) {
+          chunks.push(token);
+        }
+      }
+      return utils.mergeArrays(...chunks);
+    }
+    let done = false;
+    async function nextChunk() {
+      const result = await nextToken();
+      let chunk;
+      if (result.value !== search.MATCH) {
+        chunk = result.value;
+      } else if (!trailingCRLF) {
+        chunk = CRLF;
+      } else {
+        done = true;
+        return { value: crlfSearch.end() };
+      }
+      return { value: feedChunk(chunk) };
+    }
+    const bufferedChunks = [{ value: feedChunk(tail) }];
+    yield {
+      ...parsePartHeaders(headerLines),
+      data: {
+        [Symbol.asyncIterator]() {
+          return this;
+        },
+        async next() {
+          for (;;) {
+            const result = bufferedChunks.shift();
+            if (!result) {
+              break;
+            }
+            if (result.value.length > 0) {
+              return result;
+            }
+          }
+          for (;;) {
+            if (done) {
+              return {
+                done,
+                value: undefined
+              };
+            }
+            const result = await nextChunk();
+            if (result.value.length > 0) {
+              return result;
+            }
+          }
+        }
+      }
+    };
+    while (!done) {
+      bufferedChunks.push(await nextChunk());
+    }
+  }
+}
+async function* iterateMultipart(body, boundary) {
+  for await (const part of streamMultipart(body, boundary)) {
+    const chunks = [];
+    for await (const chunk of part.data) {
+      chunks.push(chunk);
+    }
+    yield {
+      ...part,
+      data: utils.mergeArrays(...chunks)
+    };
+  }
+}
+
+exports.iterateMultipart = iterateMultipart;
+exports.streamMultipart = streamMultipart;