@epic-web/workshop-app 4.6.5 → 4.7.0

package/node_modules/{@remix-run/server-runtime/node_modules/source-map → source-map}/lib/util.js

@@ -20,17 +20,17 @@ function getArg(aArgs, aName, aDefaultValue) {
     return aArgs[aName];
   } else if (arguments.length === 3) {
     return aDefaultValue;
-  }
+  } else {
     throw new Error('"' + aName + '" is a required argument.');
-
+  }
 }
 exports.getArg = getArg;
 
-const urlRegexp = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.-]*)(?::(\d+))?(.*)$/;
-const dataUrlRegexp = /^data:.+\,.+$/;
+var urlRegexp = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.-]*)(?::(\d+))?(.*)$/;
+var dataUrlRegexp = /^data:.+\,.+$/;
 
 function urlParse(aUrl) {
-  const match = aUrl.match(urlRegexp);
+  var match = aUrl.match(urlRegexp);
   if (!match) {
     return null;
   }
@@ -45,19 +45,19 @@ function urlParse(aUrl) {
 exports.urlParse = urlParse;
 
 function urlGenerate(aParsedUrl) {
-  let url = "";
+  var url = '';
   if (aParsedUrl.scheme) {
-    url += aParsedUrl.scheme + ":";
+    url += aParsedUrl.scheme + ':';
   }
-  url += "//";
+  url += '//';
   if (aParsedUrl.auth) {
-    url += aParsedUrl.auth + "@";
+    url += aParsedUrl.auth + '@';
   }
   if (aParsedUrl.host) {
     url += aParsedUrl.host;
   }
   if (aParsedUrl.port) {
-    url += ":" + aParsedUrl.port;
+    url += ":" + aParsedUrl.port
   }
   if (aParsedUrl.path) {
     url += aParsedUrl.path;
@@ -66,43 +66,6 @@ function urlGenerate(aParsedUrl) {
 }
 exports.urlGenerate = urlGenerate;
 
-const MAX_CACHED_INPUTS = 32;
-
-/**
- * Takes some function `f(input) -> result` and returns a memoized version of
- * `f`.
- *
- * We keep at most `MAX_CACHED_INPUTS` memoized results of `f` alive. The
- * memoization is a dumb-simple, linear least-recently-used cache.
- */
-function lruMemoize(f) {
-  const cache = [];
-
-  return function(input) {
-    for (let i = 0; i < cache.length; i++) {
-      if (cache[i].input === input) {
-        const temp = cache[0];
-        cache[0] = cache[i];
-        cache[i] = temp;
-        return cache[0].result;
-      }
-    }
-
-    const result = f(input);
-
-    cache.unshift({
-      input,
-      result,
-    });
-
-    if (cache.length > MAX_CACHED_INPUTS) {
-      cache.pop();
-    }
-
-    return result;
-  };
-}
-
 /**
  * Normalizes a path, or the path portion of a URL:
  *
@@ -114,45 +77,26 @@ function lruMemoize(f) {
  *
  * @param aPath The path or url to normalize.
  */
-const normalize = lruMemoize(function normalize(aPath) {
-  let path = aPath;
-  const url = urlParse(aPath);
+function normalize(aPath) {
+  var path = aPath;
+  var url = urlParse(aPath);
   if (url) {
     if (!url.path) {
       return aPath;
     }
     path = url.path;
   }
-  const isAbsolute = exports.isAbsolute(path);
-
-  // Split the path into parts between `/` characters. This is much faster than
-  // using `.split(/\/+/g)`.
-  const parts = [];
-  let start = 0;
-  let i = 0;
-  while (true) {
-    start = i;
-    i = path.indexOf("/", start);
-    if (i === -1) {
-      parts.push(path.slice(start));
-      break;
-    } else {
-      parts.push(path.slice(start, i));
-      while (i < path.length && path[i] === "/") {
-        i++;
-      }
-    }
-  }
+  var isAbsolute = exports.isAbsolute(path);
 
-  let up = 0;
-  for (i = parts.length - 1; i >= 0; i--) {
-    const part = parts[i];
-    if (part === ".") {
+  var parts = path.split(/\/+/);
+  for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {
+    part = parts[i];
+    if (part === '.') {
       parts.splice(i, 1);
-    } else if (part === "..") {
+    } else if (part === '..') {
       up++;
     } else if (up > 0) {
-      if (part === "") {
+      if (part === '') {
         // The first part is blank if the path is absolute. Trying to go
         // above the root is a no-op. Therefore we can remove all '..' parts
         // directly after the root.
@@ -164,10 +108,10 @@ const normalize = lruMemoize(function normalize(aPath) {
       }
     }
   }
-  path = parts.join("/");
+  path = parts.join('/');
 
-  if (path === "") {
-    path = isAbsolute ? "/" : ".";
+  if (path === '') {
+    path = isAbsolute ? '/' : '.';
   }
 
   if (url) {
@@ -175,7 +119,7 @@ const normalize = lruMemoize(function normalize(aPath) {
     return urlGenerate(url);
   }
   return path;
-});
+}
 exports.normalize = normalize;
 
 /**
@@ -201,10 +145,10 @@ function join(aRoot, aPath) {
   if (aPath === "") {
     aPath = ".";
   }
-  const aPathUrl = urlParse(aPath);
-  const aRootUrl = urlParse(aRoot);
+  var aPathUrl = urlParse(aPath);
+  var aRootUrl = urlParse(aRoot);
   if (aRootUrl) {
-    aRoot = aRootUrl.path || "/";
+    aRoot = aRootUrl.path || '/';
   }
 
   // `join(foo, '//www.example.org')`
@@ -225,9 +169,9 @@ function join(aRoot, aPath) {
     return urlGenerate(aRootUrl);
   }
 
-  const joined = aPath.charAt(0) === "/"
+  var joined = aPath.charAt(0) === '/'
     ? aPath
-    : normalize(aRoot.replace(/\/+$/, "") + "/" + aPath);
+    : normalize(aRoot.replace(/\/+$/, '') + '/' + aPath);
 
   if (aRootUrl) {
     aRootUrl.path = joined;
@@ -237,8 +181,8 @@ function join(aRoot, aPath) {
 }
 exports.join = join;
 
-exports.isAbsolute = function(aPath) {
-  return aPath.charAt(0) === "/" || urlRegexp.test(aPath);
+exports.isAbsolute = function (aPath) {
+  return aPath.charAt(0) === '/' || urlRegexp.test(aPath);
 };
 
 /**
@@ -252,15 +196,15 @@ function relative(aRoot, aPath) {
     aRoot = ".";
   }
 
-  aRoot = aRoot.replace(/\/$/, "");
+  aRoot = aRoot.replace(/\/$/, '');
 
   // It is possible for the path to be above the root. In this case, simply
   // checking whether the root is a prefix of the path won't work. Instead, we
   // need to remove components from the root one by one, until either we find
   // a prefix that fits, or we run out of components to remove.
-  let level = 0;
-  while (aPath.indexOf(aRoot + "/") !== 0) {
-    const index = aRoot.lastIndexOf("/");
+  var level = 0;
+  while (aPath.indexOf(aRoot + '/') !== 0) {
+    var index = aRoot.lastIndexOf("/");
     if (index < 0) {
       return aPath;
     }
@@ -281,12 +225,12 @@ function relative(aRoot, aPath) {
 }
 exports.relative = relative;
 
-const supportsNullProto = (function() {
-  const obj = Object.create(null);
-  return !("__proto__" in obj);
+var supportsNullProto = (function () {
+  var obj = Object.create(null);
+  return !('__proto__' in obj);
 }());
 
-function identity(s) {
+function identity (s) {
   return s;
 }
 
@@ -301,7 +245,7 @@ function identity(s) {
  */
 function toSetString(aStr) {
   if (isProtoString(aStr)) {
-    return "$" + aStr;
+    return '$' + aStr;
   }
 
   return aStr;
@@ -322,13 +266,12 @@ function isProtoString(s) {
     return false;
   }
 
-  const length = s.length;
+  var length = s.length;
 
   if (length < 9 /* "__proto__".length */) {
     return false;
   }
 
-  /* eslint-disable no-multi-spaces */
   if (s.charCodeAt(length - 1) !== 95  /* '_' */ ||
       s.charCodeAt(length - 2) !== 95  /* '_' */ ||
       s.charCodeAt(length - 3) !== 111 /* 'o' */ ||
@@ -340,9 +283,8 @@ function isProtoString(s) {
       s.charCodeAt(length - 9) !== 95  /* '_' */) {
     return false;
   }
-  /* eslint-enable no-multi-spaces */
 
-  for (let i = length - 10; i >= 0; i--) {
+  for (var i = length - 10; i >= 0; i--) {
     if (s.charCodeAt(i) !== 36 /* '$' */) {
       return false;
     }
@@ -360,7 +302,7 @@ function isProtoString(s) {
  * stubbed out mapping.
  */
 function compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {
-  let cmp = strcmp(mappingA.source, mappingB.source);
+  var cmp = strcmp(mappingA.source, mappingB.source);
   if (cmp !== 0) {
     return cmp;
   }
@@ -399,7 +341,7 @@ exports.compareByOriginalPositions = compareByOriginalPositions;
  * mapping with a stubbed out mapping.
  */
 function compareByGeneratedPositionsDeflated(mappingA, mappingB, onlyCompareGenerated) {
-  let cmp = mappingA.generatedLine - mappingB.generatedLine;
+  var cmp = mappingA.generatedLine - mappingB.generatedLine;
   if (cmp !== 0) {
     return cmp;
   }
@@ -453,7 +395,7 @@ function strcmp(aStr1, aStr2) {
  * the generated positions are compared.
  */
 function compareByGeneratedPositionsInflated(mappingA, mappingB) {
-  let cmp = mappingA.generatedLine - mappingB.generatedLine;
+  var cmp = mappingA.generatedLine - mappingB.generatedLine;
   if (cmp !== 0) {
     return cmp;
   }
@@ -488,7 +430,7 @@ exports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflate
  * JSON.
  */
 function parseSourceMapInput(str) {
-  return JSON.parse(str.replace(/^\)]}'[^\n]*\n/, ""));
+  return JSON.parse(str.replace(/^\)]}'[^\n]*\n/, ''));
 }
 exports.parseSourceMapInput = parseSourceMapInput;
 
@@ -497,12 +439,12 @@ exports.parseSourceMapInput = parseSourceMapInput;
  * URL, and the source map's URL.
  */
 function computeSourceURL(sourceRoot, sourceURL, sourceMapURL) {
-  sourceURL = sourceURL || "";
+  sourceURL = sourceURL || '';
 
   if (sourceRoot) {
     // This follows what Chrome does.
-    if (sourceRoot[sourceRoot.length - 1] !== "/" && sourceURL[0] !== "/") {
-      sourceRoot += "/";
+    if (sourceRoot[sourceRoot.length - 1] !== '/' && sourceURL[0] !== '/') {
+      sourceRoot += '/';
     }
     // The spec says:
     //   Line 4: An optional source root, useful for relocating source
@@ -527,13 +469,13 @@ function computeSourceURL(sourceRoot, sourceURL, sourceMapURL) {
   //   “sourceRoot”, the sources are resolved relative to the
   //   SourceMap (like resolving script src in a html document).
   if (sourceMapURL) {
-    const parsed = urlParse(sourceMapURL);
+    var parsed = urlParse(sourceMapURL);
     if (!parsed) {
       throw new Error("sourceMapURL could not be parsed");
     }
     if (parsed.path) {
       // Strip the last path component, but keep the "/".
-      const index = parsed.path.lastIndexOf("/");
+      var index = parsed.path.lastIndexOf('/');
       if (index >= 0) {
         parsed.path = parsed.path.substring(0, index + 1);
       }

package/node_modules/{@remix-run/server-runtime/node_modules/source-map → source-map}/package.json

@@ -1,7 +1,7 @@
 {
   "name": "source-map",
   "description": "Generates and consumes source maps",
-  "version": "0.7.4",
+  "version": "0.6.1",
   "homepage": "https://github.com/mozilla/source-map",
   "author": "Nick Fitzgerald <nfitzgerald@mozilla.com>",
   "contributors": [
@@ -47,45 +47,27 @@
     "url": "http://github.com/mozilla/source-map.git"
   },
   "main": "./source-map.js",
-  "types": "./source-map.d.ts",
   "files": [
     "source-map.js",
     "source-map.d.ts",
     "lib/",
-    "dist/source-map.js"
+    "dist/source-map.debug.js",
+    "dist/source-map.js",
+    "dist/source-map.min.js",
+    "dist/source-map.min.js.map"
   ],
   "engines": {
-    "node": ">= 8"
+    "node": ">=0.10.0"
   },
   "license": "BSD-3-Clause",
   "scripts": {
-    "lint": "eslint *.js lib/ test/",
-    "prebuild": "npm run lint",
+    "test": "npm run build && node test/run-tests.js",
     "build": "webpack --color",
-    "pretest": "npm run build",
-    "test": "node test/run-tests.js",
-    "precoverage": "npm run build",
-    "coverage": "nyc node test/run-tests.js",
-    "setup": "mkdir -p coverage && cp -n .waiting.html coverage/index.html || true",
-    "dev:live": "live-server --port=4103 --ignorePattern='(js|css|png)$' coverage",
-    "dev:watch": "watch 'npm run coverage' lib/ test/",
-    "predev": "npm run setup",
-    "dev": "npm-run-all -p --silent dev:*",
-    "clean": "rm -rf coverage .nyc_output",
     "toc": "doctoc --title '## Table of Contents' README.md && doctoc --title '## Table of Contents' CONTRIBUTING.md"
   },
   "devDependencies": {
-    "doctoc": "^1.3.1",
-    "eslint": "^4.19.1",
-    "live-server": "^1.2.0",
-    "npm-run-all": "^4.1.2",
-    "nyc": "^11.7.1",
-    "watch": "^1.0.2",
-    "webpack": "^4.9.1",
-    "webpack-cli": "^3.1"
-  },
-  "nyc": {
-    "reporter": "html"
+    "doctoc": "^0.15.0",
+    "webpack": "^1.12.0"
   },
   "typings": "source-map"
 }

package/node_modules/source-map/source-map.d.ts

@@ -0,0 +1,98 @@
+export interface StartOfSourceMap {
+    file?: string;
+    sourceRoot?: string;
+}
+
+export interface RawSourceMap extends StartOfSourceMap {
+    version: string;
+    sources: string[];
+    names: string[];
+    sourcesContent?: string[];
+    mappings: string;
+}
+
+export interface Position {
+    line: number;
+    column: number;
+}
+
+export interface LineRange extends Position {
+    lastColumn: number;
+}
+
+export interface FindPosition extends Position {
+    // SourceMapConsumer.GREATEST_LOWER_BOUND or SourceMapConsumer.LEAST_UPPER_BOUND
+    bias?: number;
+}
+
+export interface SourceFindPosition extends FindPosition {
+    source: string;
+}
+
+export interface MappedPosition extends Position {
+    source: string;
+    name?: string;
+}
+
+export interface MappingItem {
+    source: string;
+    generatedLine: number;
+    generatedColumn: number;
+    originalLine: number;
+    originalColumn: number;
+    name: string;
+}
+
+export class SourceMapConsumer {
+    static GENERATED_ORDER: number;
+    static ORIGINAL_ORDER: number;
+
+    static GREATEST_LOWER_BOUND: number;
+    static LEAST_UPPER_BOUND: number;
+
+    constructor(rawSourceMap: RawSourceMap);
+    computeColumnSpans(): void;
+    originalPositionFor(generatedPosition: FindPosition): MappedPosition;
+    generatedPositionFor(originalPosition: SourceFindPosition): LineRange;
+    allGeneratedPositionsFor(originalPosition: MappedPosition): Position[];
+    hasContentsOfAllSources(): boolean;
+    sourceContentFor(source: string, returnNullOnMissing?: boolean): string;
+    eachMapping(callback: (mapping: MappingItem) => void, context?: any, order?: number): void;
+}
+
+export interface Mapping {
+    generated: Position;
+    original: Position;
+    source: string;
+    name?: string;
+}
+
+export class SourceMapGenerator {
+    constructor(startOfSourceMap?: StartOfSourceMap);
+    static fromSourceMap(sourceMapConsumer: SourceMapConsumer): SourceMapGenerator;
+    addMapping(mapping: Mapping): void;
+    setSourceContent(sourceFile: string, sourceContent: string): void;
+    applySourceMap(sourceMapConsumer: SourceMapConsumer, sourceFile?: string, sourceMapPath?: string): void;
+    toString(): string;
+}
+
+export interface CodeWithSourceMap {
+    code: string;
+    map: SourceMapGenerator;
+}
+
+export class SourceNode {
+    constructor();
+    constructor(line: number, column: number, source: string);
+    constructor(line: number, column: number, source: string, chunk?: string, name?: string);
+    static fromStringWithSourceMap(code: string, sourceMapConsumer: SourceMapConsumer, relativePath?: string): SourceNode;
+    add(chunk: string): void;
+    prepend(chunk: string): void;
+    setSourceContent(sourceFile: string, sourceContent: string): void;
+    walk(fn: (chunk: string, mapping: MappedPosition) => void): void;
+    walkSourceContents(fn: (file: string, content: string) => void): void;
+    join(sep: string): SourceNode;
+    replaceRight(pattern: string, replacement: string): SourceNode;
+    toString(): string;
+    toStringWithSourceMap(startOfSourceMap?: StartOfSourceMap): CodeWithSourceMap;
+}

package/node_modules/source-map/source-map.js

@@ -0,0 +1,8 @@
+/*
+ * Copyright 2009-2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE.txt or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+exports.SourceMapGenerator = require('./lib/source-map-generator').SourceMapGenerator;
+exports.SourceMapConsumer = require('./lib/source-map-consumer').SourceMapConsumer;
+exports.SourceNode = require('./lib/source-node').SourceNode;

package/node_modules/turbo-stream/dist/flatten.d.ts

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

package/node_modules/turbo-stream/dist/flatten.js

@@ -6,7 +6,7 @@ function flatten(input) {
     const { indices } = this;
     const existing = indices.get(input);
     if (existing)
-        return existing;
+        return [existing];
     if (input === undefined)
         return utils_js_1.UNDEFINED;
     if (input === null)
@@ -90,14 +90,27 @@ function stringify(input, index) {
                     str[index] = `["${utils_js_1.TYPE_REGEXP}",${JSON.stringify(input.source)},${JSON.stringify(input.flags)}]`;
                 }
                 else if (input instanceof Set) {
-                    str[index] = `["${utils_js_1.TYPE_SET}",${[...input]
-                        .map((val) => flatten.call(this, val))
-                        .join(",")}]`;
+                    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) {
-                    str[index] = `["${utils_js_1.TYPE_MAP}",${[...input]
-                        .flatMap(([k, v]) => [flatten.call(this, k), flatten.call(this, v)])
-                        .join(",")}]`;
+                    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}]`;
@@ -122,8 +135,30 @@ function stringify(input, index) {
             }
             break;
         }
-        default:
-            throw new Error("Cannot encode function or unexpected type");
+        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) {
+                throw new Error("Cannot encode function or unexpected type");
+            }
+        }
     }
 }
 const objectProtoNames = Object.getOwnPropertyNames(Object.prototype)

package/node_modules/turbo-stream/dist/turbo-stream.js

@@ -121,6 +121,9 @@ function encode(input, options) {
     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`));
             }
@@ -136,7 +139,10 @@ function encode(input, options) {
                     seenPromises.add((encoder.deferred[Number(deferredId)] = raceSignal(deferred, encoder.signal)
                         .then((resolved) => {
                         const id = flatten_js_1.flatten.call(encoder, resolved);
-                        if (id < 0) {
+                        if (Array.isArray(id)) {
+                            controller.enqueue(textEncoder.encode(`${utils_js_1.TYPE_PROMISE}${deferredId}:[["${utils_js_1.TYPE_PREVIOUS_RESOLVED}",${id[0]}]]\n`));
+                        }
+                        else if (id < 0) {
                             controller.enqueue(textEncoder.encode(`${utils_js_1.TYPE_PROMISE}${deferredId}:${id}\n`));
                         }
                         else {
@@ -153,7 +159,10 @@ function encode(input, options) {
                             reason = new Error("An unknown error occurred");
                         }
                         const id = flatten_js_1.flatten.call(encoder, reason);
-                        if (id < 0) {
+                        if (Array.isArray(id)) {
+                            controller.enqueue(textEncoder.encode(`${utils_js_1.TYPE_ERROR}${deferredId}:[["${utils_js_1.TYPE_PREVIOUS_RESOLVED}",${id[0]}]]\n`));
+                        }
+                        else if (id < 0) {
                             controller.enqueue(textEncoder.encode(`${utils_js_1.TYPE_ERROR}${deferredId}:${id}\n`));
                         }
                         else {