marko 5.37.2 → 5.37.4

package/dist/compiler/index.js

@@ -4,7 +4,7 @@ var ok = require("assert").ok;
 var fs = require("fs");
 
 // eslint-disable-next-line no-constant-binary-expression
-var complain = "MARKO_DEBUG" && require("complain");
+
 var compiler = require("@marko/compiler");
 var extend = require("raptor-util/extend");
 var taglib = require("../taglib");
@@ -12,16 +12,16 @@ var globalConfig = require("./config");
 var defaults = extend({}, globalConfig);
 
 // eslint-disable-next-line no-constant-condition
-if ("MARKO_DEBUG") {
-  if (
-  require.main &&
-  require.main.filename !== require.resolve("../../bin/markoc"))
-  {
-    complain(
-      "Using `marko/compiler` has been deprecated, please upgrade to the `@marko/compiler` module."
-    );
-  }
-}
+
+
+
+
+
+
+
+
+
+
 
 var defaultOptionsExportDefinition = {
   get: function () {

package/dist/core-tags/components/init-components-tag.js

@@ -3,14 +3,14 @@
 const INIT_COMPONENTS_KEY = Symbol();
 
 const addComponentsFromContext =
-require("../../runtime/components").___addComponentsFromContext;
+require("../../runtime/components").__;
 const getInitComponentsCode =
-require("../../runtime/components").___getInitComponentsCode;
+require("../../runtime/components").a_;
 
 function addComponentsFromOut(source, target) {
   const sourceOut = source.out || source;
   const targetOut = target || sourceOut;
-  const componentsContext = sourceOut.___components;
+  const componentsContext = sourceOut.b_;
   const componentDefs = targetOut.writer.get("componentDefs");
   addComponentsFromContext(componentsContext, componentDefs);
 }
@@ -27,7 +27,7 @@ module.exports = function render(input, out) {
     $global[INIT_COMPONENTS_KEY] = true;
 
     out.on("await:finish", addComponentsFromOut);
-    out.on("___toString", addInitScript);
+    out.on("c_", addInitScript);
 
     if (out.isSync() === true) {
       // Generate initialization code for any of the UI components that were

package/dist/core-tags/components/preferred-script-location-tag.js

@@ -3,9 +3,9 @@
 function forceScriptTagAtThisPoint(out) {
   const writer = out.writer;
 
-  out.global.___isLastFlush = true;
+  out.global.d_ = true;
   const htmlSoFar = writer.toString();
-  out.global.___isLastFlush = undefined;
+  out.global.d_ = undefined;
 
   writer.clear();
   writer.write(htmlSoFar);

package/dist/core-tags/core/__flush_here_and_after__.js

@@ -16,7 +16,7 @@ module.exports = function __flushHereAndAfter__(input, out) {
     const asyncOut = out.beginAsync({ last: true });
     const nextWriter = out.writer;
 
-    out.on("___toString", (writer) => {
+    out.on("c_", (writer) => {
       if (writer instanceof BufferedWriter) {
         if (flushed) {
           const detachedOut = out.createOut();

package/dist/core-tags/core/await/AsyncValue.js

@@ -1,34 +1,34 @@
-"use strict";var queueMicrotask = require("@internal/set-immediate").___queueMicrotask;
+"use strict";var queueMicrotask = require("@internal/set-immediate").e_;
 
 function AsyncValue() {
   /**
    * The data that was provided via call to resolve(data).
    * This property is assumed to be public and available for inspection.
    */
-  this.___value = undefined;
+  this.f_ = undefined;
 
   /**
    * The data that was provided via call to reject(err)
    * This property is assumed to be public and available for inspection.
    */
-  this.___error = undefined;
+  this.g_ = undefined;
 
   /**
    * The queue of callbacks that are waiting for data
    */
-  this.___callbacks = undefined;
+  this.h_ = undefined;
 
   /**
    * The state of the data holder (STATE_INITIAL, STATE_RESOLVED, or STATE_REJECTED)
    */
-  this.___settled = false;
+  this.i_ = false;
 }
 
 function notifyCallbacks(asyncValue, err, value) {
-  var callbacks = asyncValue.___callbacks;
+  var callbacks = asyncValue.h_;
   if (callbacks) {
     // clear out the registered callbacks (we still have reference to the original value)
-    asyncValue.___callbacks = undefined;
+    asyncValue.h_ = undefined;
 
     // invoke all of the callbacks and use their scope
     for (var i = 0; i < callbacks.length; i++) {
@@ -46,14 +46,14 @@ AsyncValue.prototype = {
    * The given callback will be invoked when there is an error or resolved data
    * available.
    */
-  ___done: function (callback) {
+  j_: function (callback) {
     // Do we already have data or error?
-    if (this.___settled) {
+    if (this.i_) {
       // invoke the callback immediately
-      return callback(this.___error, this.___value);
+      return callback(this.g_, this.f_);
     }
 
-    var callbacks = this.___callbacks || (this.___callbacks = []);
+    var callbacks = this.h_ || (this.h_ = []);
     callbacks.push(callback);
   },
 
@@ -63,19 +63,19 @@ AsyncValue.prototype = {
    * its initial state so that any future requests to load data will trigger a
    * new load call.
    */
-  ___reject: function (err) {
-    if (this.___settled) {
+  k_: function (err) {
+    if (this.i_) {
       return;
     }
 
     // remember the error
-    this.___error = err;
+    this.g_ = err;
 
     // Go to the rejected state if we don't have a loader.
     // If we do have a loader then return to the initial state
     // (we do this so that next call to done() will trigger load
     // again in case the error was transient).
-    this.___settled = true;
+    this.i_ = true;
 
     // always notify callbacks regardless of whether or not we return to the initial state
     notifyCallbacks(this, err, null);
@@ -84,8 +84,8 @@ AsyncValue.prototype = {
   /**
    * This method will trigger any callbacks to be notified of data.
    */
-  ___resolve: function (value) {
-    if (this.___settled) {
+  l_: function (value) {
+    if (this.i_) {
       return;
     }
 
@@ -95,10 +95,10 @@ AsyncValue.prototype = {
 
       var finalPromise = value.then(
         function onFulfilled(value) {
-          queueMicrotask(asyncValue.___resolve.bind(asyncValue, value));
+          queueMicrotask(asyncValue.l_.bind(asyncValue, value));
         },
         function onRejected(err) {
-          queueMicrotask(asyncValue.___reject.bind(asyncValue, err));
+          queueMicrotask(asyncValue.k_.bind(asyncValue, err));
         }
       );
 
@@ -107,10 +107,10 @@ AsyncValue.prototype = {
       }
     } else {
       // remember the state
-      this.___value = value;
+      this.f_ = value;
 
       // go to the resolved state
-      this.___settled = true;
+      this.i_ = true;
 
       // notify callbacks
       notifyCallbacks(this, null, value);

package/dist/core-tags/core/await/renderer.js

@@ -1,6 +1,6 @@
 "use strict";
 // eslint-disable-next-line no-constant-binary-expression
-var complain = "MARKO_DEBUG" && require("complain");
+
 var AsyncValue = require("./AsyncValue");
 
 function safeRenderBody(renderBody, targetOut, data) {
@@ -16,18 +16,18 @@ function requestData(provider, timeout) {
 
   if (typeof provider === "function") {
     // eslint-disable-next-line no-constant-condition
-    if ("MARKO_DEBUG") {
-      complain(
-        "Passing a callback function to the <await> tag has been deprecated, please use a promise instead.",
-        { level: 1, locationIndex: 3 }
-      );
-    }
+
+
+
+
+
+
 
     var callback = function (err, data) {
       if (err) {
-        asyncValue.___reject(err);
+        asyncValue.k_(err);
       } else {
-        asyncValue.___resolve(data);
+        asyncValue.l_(data);
       }
     };
 
@@ -39,11 +39,11 @@ function requestData(provider, timeout) {
     provider(null, callback);
 
     if (value !== undefined) {
-      asyncValue.___resolve(value);
+      asyncValue.l_(value);
     }
   } else {
     // Assume the provider is a data object...
-    asyncValue.___resolve(provider);
+    asyncValue.l_(provider);
   }
 
   if (timeout == null) {
@@ -53,22 +53,22 @@ function requestData(provider, timeout) {
   var error;
   var errorMsg = "Timed out after " + timeout + "ms";
   // eslint-disable-next-line no-constant-condition
-  if ("MARKO_DEBUG") {
-    // Make sure we have a meaningful stack trace in development preparing the stacktrace upfront.
-    // If we create it inside the setTimeout, we will end up with a short, not meaningful, stack trace
-    // We only do it in development to avoid overhead in production
-    error = new Error(errorMsg);
-  }
+
+
+
+
+
+
   if (timeout > 0) {
     let timeoutId = setTimeout(function () {
       timeoutId = null;
       if (!error) error = new Error(errorMsg);
       error.code = "ERR_AWAIT_TIMEDOUT";
       error.name = "TimeoutError";
-      asyncValue.___reject(error);
+      asyncValue.k_(error);
     }, timeout);
 
-    asyncValue.___done(function () {
+    asyncValue.j_(function () {
       if (timeoutId != null) {
         clearTimeout(timeoutId);
       }
@@ -92,8 +92,8 @@ module.exports = function awaitTag(input, out) {
   var asyncValue = requestData(provider, timeout);
   var placeholderRenderer = input.placeholder && input.placeholder.renderBody;
 
-  if (asyncValue.___settled) {
-    renderContents(asyncValue.___error, asyncValue.___value, input, out);
+  if (asyncValue.i_) {
+    renderContents(asyncValue.g_, asyncValue.f_, input, out);
     return;
   }
 
@@ -111,8 +111,8 @@ module.exports = function awaitTag(input, out) {
     awaitInfo.after = input.showAfter;
 
     clientReorderContext =
-    out.global.___clientReorderContext || (
-    out.global.___clientReorderContext = {
+    out.global.m_ || (
+    out.global.m_ = {
       instances: [],
       nextId: 0
     });
@@ -218,7 +218,7 @@ module.exports = function awaitTag(input, out) {
     }
   }
 
-  asyncValue.___done(renderBody);
+  asyncValue.j_(renderBody);
 };
 
 function renderContents(err, data, input, out) {

package/dist/core-tags/core/await/reorderer-renderer.js

@@ -1,7 +1,7 @@
 "use strict";
 
 var escapeDoubleQuotes =
-require("../../../runtime/html/helpers/escape-quotes").___escapeDoubleQuotes;
+require("../../../runtime/html/helpers/escape-quotes").n_;
 
 module.exports = function (input, out) {
   // We cannot call beginSync() when using renderSync(). In this case we will
@@ -20,7 +20,7 @@ module.exports = function (input, out) {
 
   global.__awaitReordererInvoked = true;
 
-  if (out.global.___clientReorderContext) {
+  if (out.global.m_) {
     out.flush();
   }
 
@@ -35,7 +35,7 @@ module.exports = function (input, out) {
   });
 
   out.onLast(function (next) {
-    var awaitContext = global.___clientReorderContext;
+    var awaitContext = global.m_;
     var remaining;
 
     // Validate that we have remaining <await> instances that need handled
@@ -55,11 +55,11 @@ module.exports = function (input, out) {
       let flushedPlaceholder = awaitInfo.parent._state.finished;
       if (flushedPlaceholder) {
         if (awaitInfo.out._state.finished) {
-          writeResult(awaitInfo.out.___getResult());
+          writeResult(awaitInfo.out.o_());
           return;
         }
       } else {
-        awaitInfo.parent.on("___toString", () => {
+        awaitInfo.parent.on("c_", () => {
           flushedPlaceholder = true;
           if (!flushedScript && flushedContent) {
             flushedScript = true;
@@ -76,7 +76,7 @@ module.exports = function (input, out) {
       }
 
       awaitInfo.out.
-      on("___toString", out.emit.bind(out, "___toString")).
+      on("c_", out.emit.bind(out, "c_")).
       on("finish", writeResult).
       on("error", function (err) {
         asyncOut.error(err);

package/dist/node-require/browser-refresh.js

@@ -1,18 +1 @@
-"use strict"; // eslint-disable-next-line no-constant-condition
-if ("MARKO_DEBUG") {
-  const browserRefreshClient = require("browser-refresh-client");
-  if (browserRefreshClient.isBrowserRefreshEnabled()) {
-    const extensions = require(".").getExtensions();
-    const hotReload = require("./hot-reload");
-
-    browserRefreshClient.
-    enableSpecialReload(
-      `${extensions.
-      map((ext) => `*${ext}`).
-      join(" ")} marko.json marko-tag.json`
-    ).
-    onFileModified((path) => {
-      hotReload.handleFileModified(path);
-    });
-  }
-}
+"use strict";

package/dist/node-require/index.js

@@ -1,12 +1,12 @@
 "use strict";
 // eslint-disable-next-line no-constant-binary-expression
-const complain = "MARKO_DEBUG" && require("complain");
+
 const path = require("path");
 const resolveFrom = require("resolve-from");
 const requiredCompilerOptions = { modules: "cjs" };
 const defaultCompilerOptions = {
   // eslint-disable-next-line no-constant-condition
-  sourceMaps: "MARKO_DEBUG" ? "inline" : false,
+  sourceMaps: false,
   meta: true,
   babelConfig: {
     babelrc: false,
@@ -17,11 +17,11 @@ const defaultCompilerOptions = {
 const MARKO_EXTENSIONS = Symbol("MARKO_EXTENSIONS");
 
 // eslint-disable-next-line no-constant-condition
-if ("MARKO_DEBUG") {
-  complain(
-    'Using "marko/node-require" has been replaced with "@marko/compiler/register".'
-  );
-}
+
+
+
+
+
 
 function normalizeExtension(extension) {
   if (extension.charAt(0) !== ".") {

package/dist/node_modules/@internal/components-beginComponent/index-browser.js

@@ -7,17 +7,17 @@ key,
 ownerComponentDef)
 {
   var componentId = component.id;
-  var componentDef = componentsContext.___componentDef = new ComponentDef(
+  var componentDef = componentsContext.p_ = new ComponentDef(
     component,
     componentId,
     componentsContext
   );
-  componentsContext.___globalContext.___renderedComponentsById[
+  componentsContext.q_.r_[
   componentId] =
   true;
-  componentsContext.___components.push(componentDef);
+  componentsContext.b_.push(componentDef);
 
-  var out = componentsContext.___out;
-  out.bc(component, key, ownerComponentDef && ownerComponentDef.___component);
+  var out = componentsContext.s_;
+  out.bc(component, key, ownerComponentDef && ownerComponentDef.t_);
   return componentDef;
 };

package/dist/node_modules/@internal/components-beginComponent/index.js

@@ -21,20 +21,20 @@ existingComponentDef)
   // widget.  It should be removed when the legacy compat layer is removed.
   var componentDef =
   existingComponentDef || (
-  componentsContext.___componentDef = new ComponentDef(
+  componentsContext.p_ = new ComponentDef(
     component,
     componentId,
     componentsContext
   ));
 
   var ownerIsRenderBoundary =
-  ownerComponentDef && ownerComponentDef.___renderBoundary;
+  ownerComponentDef && ownerComponentDef.u_;
   var ownerWillRerender =
   ownerComponentDef &&
-  ownerComponentDef.___flags & FLAG_WILL_RERENDER_IN_BROWSER;
+  ownerComponentDef.v_ & FLAG_WILL_RERENDER_IN_BROWSER;
   // On the server
-  if (!componentsContext.___isPreserved && ownerWillRerender) {
-    componentDef.___flags |= FLAG_WILL_RERENDER_IN_BROWSER;
+  if (!componentsContext.w_ && ownerWillRerender) {
+    componentDef.v_ |= FLAG_WILL_RERENDER_IN_BROWSER;
     componentDef._wrr = true;
     return componentDef;
   }
@@ -46,22 +46,22 @@ existingComponentDef)
     return componentDef;
   }
 
-  componentsContext.___components.push(componentDef);
+  componentsContext.b_.push(componentDef);
 
-  let out = componentsContext.___out;
+  let out = componentsContext.s_;
   let runtimeId = out.global.runtimeId;
 
-  componentDef.___renderBoundary = true;
-  componentDef.___parentPreserved = componentsContext.___isPreserved;
+  componentDef.u_ = true;
+  componentDef.x_ = componentsContext.w_;
 
   if (isSplitComponent === false && out.global.noBrowserRerender !== true) {
-    componentDef.___flags |= FLAG_WILL_RERENDER_IN_BROWSER;
+    componentDef.v_ |= FLAG_WILL_RERENDER_IN_BROWSER;
     componentDef._wrr = true;
-    componentsContext.___isPreserved = false;
+    componentsContext.w_ = false;
   }
 
   if (out.global.oldHydrateNoCreate === true) {
-    componentDef.___flags |= FLAG_OLD_HYDRATE_NO_CREATE;
+    componentDef.v_ |= FLAG_OLD_HYDRATE_NO_CREATE;
   }
 
   if ((ownerIsRenderBoundary || ownerWillRerender) && key != null) {