@malloy-publisher/server 0.8.4 → 0.9.0

package/dist/package_load_worker.mjs

@@ -131,6 +131,10 @@ var require_brace_expansion = __commonJS((exports, module) => {
   var escClose = "\x00CLOSE" + Math.random() + "\x00";
   var escComma = "\x00COMMA" + Math.random() + "\x00";
   var escPeriod = "\x00PERIOD" + Math.random() + "\x00";
+  var EXPANSION_MAX = 1e5;
+  var EXPANSION_MAX_LENGTH = 4000000;
+  var EXPANSION_MAX_DEPTH = 1000;
+  var EXPANSION_MAX_REWRITES = 1000;
   function numeric(str) {
     return parseInt(str, 10) == str ? parseInt(str, 10) : str.charCodeAt(0);
   }
@@ -140,33 +144,49 @@ var require_brace_expansion = __commonJS((exports, module) => {
   function unescapeBraces(str) {
     return str.split(escSlash).join("\\").split(escOpen).join("{").split(escClose).join("}").split(escComma).join(",").split(escPeriod).join(".");
   }
+  function pushAll(target, items) {
+    for (var i = 0;i < items.length; i++) {
+      target.push(items[i]);
+    }
+  }
   function parseCommaParts(str) {
-    if (!str)
-      return [""];
     var parts = [];
-    var m = balanced("{", "}", str);
-    if (!m)
-      return str.split(",");
-    var pre = m.pre;
-    var body = m.body;
-    var post = m.post;
-    var p = pre.split(",");
-    p[p.length - 1] += "{" + body + "}";
-    var postParts = parseCommaParts(post);
-    if (post.length) {
-      p[p.length - 1] += postParts.shift();
-      p.push.apply(p, postParts);
-    }
-    parts.push.apply(parts, p);
-    return parts;
-  }
-  function expandTop(str) {
+    var carry = "";
+    for (;; ) {
+      var m = balanced("{", "}", str);
+      if (!m) {
+        var tail = str.split(",");
+        tail[0] = carry + tail[0];
+        pushAll(parts, tail);
+        return parts;
+      }
+      var pre = m.pre;
+      var body = m.body;
+      var post = m.post;
+      var p = pre.split(",");
+      p[0] = carry + p[0];
+      p[p.length - 1] += "{" + body + "}";
+      if (!post.length) {
+        pushAll(parts, p);
+        return parts;
+      }
+      carry = p.pop();
+      pushAll(parts, p);
+      str = post;
+    }
+  }
+  function expandTop(str, options) {
     if (!str)
       return [];
+    options = options || {};
+    var max = options.max == null ? EXPANSION_MAX : options.max;
+    var maxLength = options.maxLength == null ? EXPANSION_MAX_LENGTH : options.maxLength;
+    var maxDepth = options.maxDepth == null ? EXPANSION_MAX_DEPTH : options.maxDepth;
+    var maxRewrites = options.maxRewrites == null ? EXPANSION_MAX_REWRITES : options.maxRewrites;
     if (str.substr(0, 2) === "{}") {
       str = "\\{\\}" + str.substr(2);
     }
-    return expand(escapeBraces(str), true).map(unescapeBraces);
+    return expand(escapeBraces(str), max, maxLength, maxDepth, 0, maxRewrites, true).map(unescapeBraces);
   }
   function embrace(str) {
     return "{" + str + "}";
@@ -180,87 +200,161 @@ var require_brace_expansion = __commonJS((exports, module) => {
   function gte(i, y) {
     return i >= y;
   }
-  function expand(str, isTop) {
-    var expansions = [];
-    var m = balanced("{", "}", str);
-    if (!m || /\$$/.test(m.pre))
-      return [str];
-    var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
-    var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
-    var isSequence = isNumericSequence || isAlphaSequence;
-    var isOptions = m.body.indexOf(",") >= 0;
-    if (!isSequence && !isOptions) {
-      if (m.post.match(/,(?!,).*\}/)) {
-        str = m.pre + "{" + m.body + escClose + m.post;
-        return expand(str);
+  function combine(acc, base, pre, values, max, maxLength, dropEmpties, outBase) {
+    var out = [];
+    var length = 0;
+    for (var a = 0;a < acc.length; a++) {
+      for (var v = 0;v < values.length; v++) {
+        if (out.length >= max)
+          return out;
+        var expansion = acc[a] + pre + values[v];
+        if (dropEmpties && expansion.length === base[a])
+          continue;
+        if (length + expansion.length > maxLength)
+          return out;
+        out.push(expansion);
+        outBase.push(base[a]);
+        length += expansion.length;
       }
-      return [str];
     }
-    var n;
-    if (isSequence) {
-      n = m.body.split(/\.\./);
-    } else {
-      n = parseCommaParts(m.body);
-      if (n.length === 1) {
-        n = expand(n[0], false).map(embrace);
-        if (n.length === 1) {
-          var post = m.post.length ? expand(m.post, false) : [""];
-          return post.map(function(p) {
-            return m.pre + n[0] + p;
-          });
+    return out;
+  }
+  function expandSequence(body, isAlphaSequence, max, maxLength) {
+    var n = body.split(/\.\./);
+    var N = [];
+    if (n[0] === undefined || n[1] === undefined) {
+      return N;
+    }
+    var x = numeric(n[0]);
+    var y = numeric(n[1]);
+    var width = Math.max(n[0].length, n[1].length);
+    var incr = n.length === 3 && n[2] !== undefined ? Math.max(Math.abs(numeric(n[2])), 1) : 1;
+    var test = lte;
+    var reverse = y < x;
+    if (reverse) {
+      incr *= -1;
+      test = gte;
+    }
+    var pad = n.some(isPadded);
+    var length = 0;
+    for (var i = x;test(i, y) && N.length < max; i += incr) {
+      var c;
+      if (isAlphaSequence) {
+        c = String.fromCharCode(i);
+        if (c === "\\") {
+          c = "";
         }
-      }
-    }
-    var pre = m.pre;
-    var post = m.post.length ? expand(m.post, false) : [""];
-    var N;
-    if (isSequence) {
-      var x = numeric(n[0]);
-      var y = numeric(n[1]);
-      var width = Math.max(n[0].length, n[1].length);
-      var incr = n.length == 3 ? Math.abs(numeric(n[2])) : 1;
-      var test = lte;
-      var reverse = y < x;
-      if (reverse) {
-        incr *= -1;
-        test = gte;
-      }
-      var pad = n.some(isPadded);
-      N = [];
-      for (var i = x;test(i, y); i += incr) {
-        var c;
-        if (isAlphaSequence) {
-          c = String.fromCharCode(i);
-          if (c === "\\")
-            c = "";
-        } else {
-          c = String(i);
-          if (pad) {
-            var need = width - c.length;
-            if (need > 0) {
-              var z = new Array(need + 1).join("0");
-              if (i < 0)
-                c = "-" + z + c.slice(1);
-              else
-                c = z + c;
+      } else {
+        c = String(i);
+        if (pad) {
+          var need = width - c.length;
+          if (need > 0) {
+            var z = new Array(need + 1).join("0");
+            if (i < 0) {
+              c = "-" + z + c.slice(1);
+            } else {
+              c = z + c;
             }
           }
         }
-        N.push(c);
       }
-    } else {
-      N = concatMap(n, function(el) {
-        return expand(el, false);
-      });
+      if (length + c.length > maxLength)
+        break;
+      N.push(c);
+      length += c.length;
     }
-    for (var j = 0;j < N.length; j++) {
-      for (var k = 0;k < post.length; k++) {
-        var expansion = pre + N[j] + post[k];
-        if (!isTop || isSequence || expansion)
-          expansions.push(expansion);
+    return N;
+  }
+  function expand(str, max, maxLength, maxDepth, depth, maxRewrites, isTop) {
+    if (depth > maxDepth) {
+      return [str];
+    }
+    var acc = [""];
+    var accBase = [0];
+    var rewrites = 0;
+    var dropEmpties = false;
+    var firstGroup = true;
+    var nextBase;
+    for (;; ) {
+      var m = balanced("{", "}", str);
+      if (!m) {
+        return combine(acc, accBase, str, [""], max, maxLength, dropEmpties, []);
+      }
+      var pre = m.pre;
+      if (/\$$/.test(pre)) {
+        return combine(acc, accBase, str, [""], max, maxLength, dropEmpties, []);
+      }
+      var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
+      var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
+      var isSequence = isNumericSequence || isAlphaSequence;
+      var isOptions = m.body.indexOf(",") >= 0;
+      if (!isSequence && !isOptions) {
+        if (rewrites < maxRewrites && m.post.match(/,(?!,).*\}/)) {
+          rewrites++;
+          str = m.pre + "{" + m.body + escClose + m.post;
+          isTop = true;
+          firstGroup = true;
+          dropEmpties = false;
+          accBase = [];
+          for (var b = 0;b < acc.length; b++) {
+            accBase.push(acc[b].length);
+          }
+          continue;
+        }
+        return combine(acc, accBase, pre + "{" + m.body + "}" + m.post, [""], max, maxLength, dropEmpties, []);
       }
+      if (firstGroup) {
+        dropEmpties = isTop && !isSequence;
+        firstGroup = false;
+      }
+      var values;
+      if (isSequence) {
+        values = expandSequence(m.body, isAlphaSequence, max, maxLength);
+      } else {
+        var n = parseCommaParts(m.body);
+        if (n.length === 1 && n[0] !== undefined) {
+          n = expand(n[0], max, maxLength, maxDepth, depth + 1, maxRewrites, false).map(embrace);
+          if (n.length === 1) {
+            nextBase = [];
+            acc = combine(acc, accBase, pre + n[0], [""], max, maxLength, dropEmpties && !m.post.length, nextBase);
+            accBase = nextBase;
+            if (!m.post.length)
+              break;
+            str = m.post;
+            continue;
+          }
+        }
+        var dropsEmpties = dropEmpties && !m.post.length && !pre;
+        for (var d = 0;dropsEmpties && d < acc.length; d++) {
+          if (acc[d].length !== accBase[d]) {
+            dropsEmpties = false;
+          }
+        }
+        values = [];
+        var valuesLength = 0;
+        outer:
+          for (var j = 0;j < n.length; j++) {
+            var expanded = expand(n[j], max, maxLength, maxDepth, depth + 1, maxRewrites, false);
+            for (var k = 0;k < expanded.length; k++) {
+              var v = expanded[k];
+              if (dropsEmpties && !v)
+                continue;
+              if (values.length >= max || valuesLength + v.length > maxLength) {
+                break outer;
+              }
+              values.push(v);
+              valuesLength += v.length;
+            }
+          }
+      }
+      nextBase = [];
+      acc = combine(acc, accBase, pre, values, max, maxLength, dropEmpties && !m.post.length, nextBase);
+      accBase = nextBase;
+      if (!m.post.length)
+        break;
+      str = m.post;
     }
-    return expansions;
+    return acc;
   }
 });
 
@@ -370,6 +464,7 @@ var require_minimatch = __commonJS((exports, module) => {
       pattern = pattern.split(path.sep).join("/");
     }
     this.options = options;
+    this.maxGlobstarRecursion = options.maxGlobstarRecursion !== undefined ? options.maxGlobstarRecursion : 200;
     this.set = [];
     this.pattern = pattern;
     this.regexp = null;
@@ -528,6 +623,8 @@ var require_minimatch = __commonJS((exports, module) => {
             re += c;
             continue;
           }
+          if (c === "*" && stateChar === "*")
+            continue;
           self2.debug("call clearStateChar %j", stateChar);
           clearStateChar();
           stateChar = c;
@@ -776,52 +873,127 @@ var require_minimatch = __commonJS((exports, module) => {
     return this.negate;
   };
   Minimatch.prototype.matchOne = function(file, pattern, partial) {
-    var options = this.options;
-    this.debug("matchOne", { this: this, file, pattern });
-    this.debug("matchOne", file.length, pattern.length);
-    for (var fi = 0, pi = 0, fl = file.length, pl = pattern.length;fi < fl && pi < pl; fi++, pi++) {
-      this.debug("matchOne loop");
-      var p = pattern[pi];
-      var f = file[fi];
-      this.debug(pattern, p, f);
-      if (p === false)
+    if (pattern.indexOf(GLOBSTAR) !== -1) {
+      return this._matchGlobstar(file, pattern, partial, 0, 0);
+    }
+    return this._matchOne(file, pattern, partial, 0, 0);
+  };
+  Minimatch.prototype._matchGlobstar = function(file, pattern, partial, fileIndex, patternIndex) {
+    var i;
+    var firstgs = -1;
+    for (i = patternIndex;i < pattern.length; i++) {
+      if (pattern[i] === GLOBSTAR) {
+        firstgs = i;
+        break;
+      }
+    }
+    var lastgs = -1;
+    for (i = pattern.length - 1;i >= 0; i--) {
+      if (pattern[i] === GLOBSTAR) {
+        lastgs = i;
+        break;
+      }
+    }
+    var head = pattern.slice(patternIndex, firstgs);
+    var body = partial ? pattern.slice(firstgs + 1) : pattern.slice(firstgs + 1, lastgs);
+    var tail = partial ? [] : pattern.slice(lastgs + 1);
+    if (head.length) {
+      var fileHead = file.slice(fileIndex, fileIndex + head.length);
+      if (!this._matchOne(fileHead, head, partial, 0, 0)) {
         return false;
-      if (p === GLOBSTAR) {
-        this.debug("GLOBSTAR", [pattern, p, f]);
-        var fr = fi;
-        var pr = pi + 1;
-        if (pr === pl) {
-          this.debug("** at the end");
-          for (;fi < fl; fi++) {
-            if (file[fi] === "." || file[fi] === ".." || !options.dot && file[fi].charAt(0) === ".")
-              return false;
-          }
-          return true;
+      }
+      fileIndex += head.length;
+    }
+    var fileTailMatch = 0;
+    if (tail.length) {
+      if (tail.length + fileIndex > file.length)
+        return false;
+      var tailStart = file.length - tail.length;
+      if (this._matchOne(file, tail, partial, tailStart, 0)) {
+        fileTailMatch = tail.length;
+      } else {
+        if (file[file.length - 1] !== "" || fileIndex + tail.length === file.length) {
+          return false;
         }
-        while (fr < fl) {
-          var swallowee = file[fr];
-          this.debug(`
-globstar while`, file, fr, pattern, pr, swallowee);
-          if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
-            this.debug("globstar found match!", fr, fl, swallowee);
-            return true;
-          } else {
-            if (swallowee === "." || swallowee === ".." || !options.dot && swallowee.charAt(0) === ".") {
-              this.debug("dot detected!", file, fr, pattern, pr);
-              break;
-            }
-            this.debug("globstar swallow a segment, and continue");
-            fr++;
-          }
+        tailStart--;
+        if (!this._matchOne(file, tail, partial, tailStart, 0)) {
+          return false;
+        }
+        fileTailMatch = tail.length + 1;
+      }
+    }
+    if (!body.length) {
+      var sawSome = !!fileTailMatch;
+      for (i = fileIndex;i < file.length - fileTailMatch; i++) {
+        var f = String(file[i]);
+        sawSome = true;
+        if (f === "." || f === ".." || !this.options.dot && f.charAt(0) === ".") {
+          return false;
+        }
+      }
+      return partial || sawSome;
+    }
+    var bodySegments = [[[], 0]];
+    var currentBody = bodySegments[0];
+    var nonGsParts = 0;
+    var nonGsPartsSums = [0];
+    for (var bi = 0;bi < body.length; bi++) {
+      var b = body[bi];
+      if (b === GLOBSTAR) {
+        nonGsPartsSums.push(nonGsParts);
+        currentBody = [[], 0];
+        bodySegments.push(currentBody);
+      } else {
+        currentBody[0].push(b);
+        nonGsParts++;
+      }
+    }
+    var idx = bodySegments.length - 1;
+    var fileLength = file.length - fileTailMatch;
+    for (var si = 0;si < bodySegments.length; si++) {
+      bodySegments[si][1] = fileLength - (nonGsPartsSums[idx--] + bodySegments[si][0].length);
+    }
+    return !!this._matchGlobStarBodySections(file, bodySegments, fileIndex, 0, partial, 0, !!fileTailMatch);
+  };
+  Minimatch.prototype._matchGlobStarBodySections = function(file, bodySegments, fileIndex, bodyIndex, partial, globStarDepth, sawTail) {
+    var bs = bodySegments[bodyIndex];
+    if (!bs) {
+      for (var i = fileIndex;i < file.length; i++) {
+        sawTail = true;
+        var f = file[i];
+        if (f === "." || f === ".." || !this.options.dot && f.charAt(0) === ".") {
+          return false;
         }
-        if (partial) {
-          this.debug(`
->>> no match, partial?`, file, fr, pattern, pr);
-          if (fr === fl)
-            return true;
+      }
+      return sawTail;
+    }
+    var body = bs[0];
+    var after = bs[1];
+    while (fileIndex <= after) {
+      var m = this._matchOne(file.slice(0, fileIndex + body.length), body, partial, fileIndex, 0);
+      if (m && globStarDepth < this.maxGlobstarRecursion) {
+        var sub = this._matchGlobStarBodySections(file, bodySegments, fileIndex + body.length, bodyIndex + 1, partial, globStarDepth + 1, sawTail);
+        if (sub !== false) {
+          return sub;
         }
+      }
+      var f = file[fileIndex];
+      if (f === "." || f === ".." || !this.options.dot && f.charAt(0) === ".") {
         return false;
       }
+      fileIndex++;
+    }
+    return partial || null;
+  };
+  Minimatch.prototype._matchOne = function(file, pattern, partial, fileIndex, patternIndex) {
+    var fi, pi, fl, pl;
+    for (fi = fileIndex, pi = patternIndex, fl = file.length, pl = pattern.length;fi < fl && pi < pl; fi++, pi++) {
+      this.debug("matchOne loop");
+      var p = pattern[pi];
+      var f = file[fi];
+      this.debug(pattern, p, f);
+      if (p === false || p === GLOBSTAR)
+        return false;
       var hit;
       if (typeof p === "string") {
         hit = f === p;
@@ -15212,72 +15384,21 @@ function onMotlyRoute(text) {
 function hasEnvReference(annotation) {
   return annotation.includes("@env.");
 }
-function pollutionTargets() {
-  const targets = [Object.prototype];
-  for (const key of Object.getOwnPropertyNames(Object.prototype)) {
-    const descriptor = Object.getOwnPropertyDescriptor(Object.prototype, key);
-    if (!descriptor)
-      continue;
-    let value;
-    if ("value" in descriptor) {
-      value = descriptor.value;
-    } else {
-      if (BUILT_IN_PROTO_GETTER === undefined || descriptor.get !== BUILT_IN_PROTO_GETTER) {
-        return;
-      }
-      continue;
-    }
-    if ((typeof value === "object" || typeof value === "function") && value !== null && !targets.includes(value)) {
-      targets.push(value);
-    }
-  }
-  return targets;
-}
-function parseGuarded(texts) {
-  const targets = pollutionTargets();
-  if (targets === undefined) {
-    return { tag: undefined, messages: [UNSAFE_TO_PARSE] };
-  }
-  let unreadable = false;
-  const ownNames = (target) => {
-    try {
-      return Object.getOwnPropertyNames(target);
-    } catch {
-      unreadable = true;
-      return [];
-    }
-  };
-  const before = targets.map(ownNames);
-  if (unreadable)
-    return { tag: undefined, messages: [UNSAFE_TO_PARSE] };
-  const undoPollution = () => {
-    let polluted = false;
-    targets.forEach((target, index) => {
-      for (const key of ownNames(target)) {
-        if (before[index].includes(key))
-          continue;
-        polluted = true;
-        try {
-          delete target[key];
-        } catch {}
-      }
-    });
-    return polluted || unreadable;
-  };
+function parseBounded(texts) {
   if (texts.some((text) => text.length > MAX_ANNOTATION_CHARS)) {
     return { tag: undefined, messages: [ANNOTATION_TOO_LONG] };
   }
   try {
     const result = parseAnnotation([...texts]);
-    if (undoPollution())
-      return { tag: undefined, messages: [UNSAFE_TO_PARSE] };
     return {
       tag: result.tag,
       messages: result.log.map((error) => error.message)
     };
-  } catch {
-    undoPollution();
-    return { tag: undefined, messages: [UNSAFE_TO_PARSE] };
+  } catch (error) {
+    return {
+      tag: undefined,
+      messages: [error instanceof Error ? error.message : String(error)]
+    };
   }
 }
 function docCommentText(texts) {
@@ -15409,16 +15530,16 @@ function parseMotly(texts) {
   const envErrors = envDropped > 0 ? [ENV_REFERENCE_DROPPED] : [];
   if (motly.length === 0)
     return { tag: undefined, errors: envErrors };
-  const direct = parseGuarded(motly);
+  const direct = parseBounded(motly);
   if (direct.messages.length === 0)
     return { tag: direct.tag, errors: envErrors };
   const rescued = motly.map((text) => {
-    if (parseGuarded([text]).messages.length === 0)
+    if (parseBounded([text]).messages.length === 0)
       return text;
     const rewritten = quoteFilterLiterals(text);
-    return parseGuarded([rewritten]).messages.length === 0 ? rewritten : text;
+    return parseBounded([rewritten]).messages.length === 0 ? rewritten : text;
   });
-  const after = parseGuarded(rescued);
+  const after = parseBounded(rescued);
   return { tag: after.tag, errors: [...envErrors, ...after.messages] };
 }
 function tagText(tag, ...path) {
@@ -15484,9 +15605,8 @@ function readStartingGivens(tag, declaredType) {
   }
   return Object.keys(collected).length > 0 ? collected : undefined;
 }
-var BUILT_IN_PROTO_GETTER, MAX_ANNOTATION_CHARS = 8192, ANNOTATION_TOO_LONG, ENV_REFERENCE_DROPPED = "annotation dropped for carrying an @env. reference", UNSAFE_TO_PARSE = "annotation could not be parsed safely";
+var MAX_ANNOTATION_CHARS = 8192, ANNOTATION_TOO_LONG, ENV_REFERENCE_DROPPED = "annotation dropped for carrying an @env. reference";
 var init_motly = __esm(() => {
-  BUILT_IN_PROTO_GETTER = Object.getOwnPropertyDescriptor(Object.prototype, "__proto__")?.get;
   ANNOTATION_TOO_LONG = `annotation exceeds ${MAX_ANNOTATION_CHARS} characters and was not parsed`;
 });
 
@@ -23219,9 +23339,6 @@ function lintDashboard(facts, manifest) {
   return findings;
 }
 function describeParseFailure(message) {
-  if (message === UNSAFE_TO_PARSE) {
-    return `was refused rather than parsed (${message}), which can be caused by something outside this file`;
-  }
   if (message === ENV_REFERENCE_DROPPED) {
     return `was dropped rather than parsed (${message}), so nothing on that line took effect`;
   }