@marko/compiler 5.39.50 → 5.39.52

package/dist/babel-types/traverse/patch.js

@@ -1,133 +0,0 @@
-"use strict";require("../types/patch");
-
-var _traverse = _interopRequireWildcard(require("@babel/traverse"));
-var t = _interopRequireWildcard(require("@babel/types"));
-
-var _definitions = require("../types/definitions");function _interopRequireWildcard(e, t) {if ("function" == typeof WeakMap) var r = new WeakMap(),n = new WeakMap();return (_interopRequireWildcard = function (e, t) {if (!t && e && e.__esModule) return e;var o,i,f = { __proto__: null, default: e };if (null === e || "object" != typeof e && "function" != typeof e) return f;if (o = t ? n : r) {if (o.has(e)) return o.get(e);o.set(e, f);}for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]);return f;})(e, t);}
-
-_definitions.MARKO_TYPES.forEach((typeName) => {
-  const checkKey = `is${typeName}`;
-  const assertKey = `assert${typeName}`;
-  const checkFn = t[checkKey];
-  const assertFn = t[assertKey];
-  _traverse.NodePath.prototype[checkKey] = function (opts) {
-    return checkFn(this.node, opts);
-  };
-  _traverse.NodePath.prototype[assertKey] = function (opts) {
-    assertFn(this.node, opts);
-  };
-});
-
-_definitions.MARKO_ALIAS_TYPES.forEach((aliasName) => {
-  const checkKey = `is${aliasName}`;
-  const originalProtoCheck = _traverse.NodePath.prototype[checkKey];
-  _traverse.NodePath.prototype[checkKey] = function (opts) {
-    return (
-      t.is(aliasName, this.node, opts) ||
-      originalProtoCheck.call(this, this.node, opts));
-
-  };
-});
-
-// Adds a one time patch to the scope collector visitors to include
-// Marko bindings for params and tag vars.
-const originalCrawl = _traverse.Scope.prototype.crawl;
-const patchedVisitors = new WeakSet();
-
-_traverse.Scope.prototype.crawl = function () {
-  const path = this.path;
-  const originalTraverse = path.traverse;
-  path.traverse = function (visitor, state) {
-    state.hoistableTagVarsByScope = new Map();
-    path.traverse = originalTraverse;
-
-    if (!patchedVisitors.has(visitor)) {
-      patchedVisitors.add(visitor);
-      Object.assign(
-        _traverse.default.explode(visitor),
-        _traverse.default.explode({
-          MarkoTagBody(body) {
-            for (const param of body.get("params")) {
-              body.scope.registerBinding("param", param);
-            }
-          },
-          MarkoTag(tag, state) {
-            const tagVar = tag.get("var");
-            if (tagVar.node) {
-              tag.scope.registerBinding("local", tagVar, tag);
-              for (const name in tagVar.getBindingIdentifiers()) {
-                let curScope = tag.scope;
-                const binding = curScope.getBinding(name);
-
-                while (curScope = curScope.parent) {
-                  const hoistableTagVars =
-                  state.hoistableTagVarsByScope.get(curScope);
-
-                  if (hoistableTagVars) {
-                    hoistableTagVars[name] = hoistableTagVars[name] ?
-                    true :
-                    binding;
-                  } else {
-                    state.hoistableTagVarsByScope.set(curScope, {
-                      [name]: binding
-                    });
-                  }
-                }
-              }
-            }
-          }
-        })
-      );
-    }
-
-    if (this.type === "Program" && this.node.params?.length) {
-      this.scope.registerBinding("params", this);
-    }
-
-    this.traverse(visitor, state);
-
-    if (state.references.length) {
-      const movedBindings = new Map();
-      for (const ref of state.references) {
-        const { name } = ref.node;
-        let curScope = ref.scope;
-        if (curScope.hasBinding(name)) continue;
-
-        do {
-          const hoistableBinding =
-          state.hoistableTagVarsByScope.get(curScope)?.[name];
-
-          if (hoistableBinding) {
-            if (hoistableBinding === true) {
-              throw ref.buildCodeFrameError(
-                "Ambiguous reference, variable was defined in multiple places and was not shadowed."
-              );
-            }
-
-            const movedBinding = movedBindings.get(hoistableBinding);
-            if (
-            !movedBinding ||
-            getScopeDepth(movedBinding) > getScopeDepth(curScope))
-            {
-              movedBindings.set(hoistableBinding, curScope);
-            }
-          }
-        } while (curScope = curScope.parent);
-      }
-
-      for (const [binding, scope] of movedBindings) {
-        binding.scope.moveBindingTo(binding.identifier.name, scope);
-      }
-    }
-  };
-
-  originalCrawl.call(this);
-  path.traverse = originalTraverse;
-};
-
-function getScopeDepth(scope) {
-  let depth = 0;
-  let cur = scope;
-  while (cur = cur.parent) depth++;
-  return depth;
-}

package/dist/babel-types/types/definitions.js

@@ -1,254 +0,0 @@
-"use strict";exports.__esModule = true;exports.default = exports.MARKO_TYPES = exports.MARKO_ALIAS_TYPES = void 0;var _utils = require("@babel/types/lib/definitions/utils");
-
-
-
-
-
-
-
-const valueFieldCommon = {
-  value: {
-    validate: (0, _utils.assertValueType)("string")
-  }
-};
-
-const MarkoDefinitions = {
-  MarkoParseError: {
-    aliases: ["Marko", "Expression", "Statement"],
-    builder: ["source", "label", "errorLoc"],
-    fields: {
-      source: {
-        validate: (0, _utils.assertValueType)("string")
-      },
-      label: {
-        validate: (0, _utils.assertValueType)("string")
-      },
-      errorLoc: {
-        optional: true,
-        validate: (0, _utils.assertValueType)("object")
-      }
-    }
-  },
-  MarkoDocumentType: {
-    aliases: ["Marko", "Statement"],
-    builder: ["value"],
-    fields: { ...valueFieldCommon }
-  },
-
-  MarkoDeclaration: {
-    aliases: ["Marko", "Statement"],
-    builder: ["value"],
-    fields: { ...valueFieldCommon }
-  },
-
-  MarkoCDATA: {
-    aliases: ["Marko", "Statement"],
-    builder: ["value"],
-    fields: { ...valueFieldCommon }
-  },
-
-  MarkoComment: {
-    aliases: ["Marko", "Statement"],
-    builder: ["value"],
-    fields: { ...valueFieldCommon }
-  },
-
-  MarkoText: {
-    aliases: ["Marko", "Statement"],
-    builder: ["value"],
-    fields: { ...valueFieldCommon }
-  },
-
-  MarkoPlaceholder: {
-    aliases: ["Marko", "Statement"],
-    builder: ["value", "escape"],
-    visitor: ["value"],
-    fields: {
-      value: {
-        validate: (0, _utils.assertNodeType)("Expression")
-      },
-      escape: {
-        validate: (0, _utils.assertValueType)("boolean"),
-        default: true
-      }
-    }
-  },
-
-  MarkoScriptlet: {
-    aliases: ["Marko", "Statement"],
-    builder: ["body", "static", "target"],
-    visitor: ["body"],
-    fields: {
-      body: {
-        validate: arrayOfType(["Statement"])
-      },
-      static: {
-        validate: (0, _utils.assertValueType)("boolean"),
-        default: false
-      },
-      target: {
-        validate: (0, _utils.assertOneOf)("server", "client"),
-        optional: true
-      }
-    }
-  },
-
-  MarkoClass: {
-    aliases: ["Marko", "Statement", "Class"],
-    builder: ["body"],
-    visitor: ["body"],
-    fields: {
-      body: {
-        validate: (0, _utils.assertNodeType)("ClassBody")
-      }
-    }
-  },
-
-  MarkoAttribute: {
-    aliases: ["Marko"],
-    builder: ["name", "value", "modifier", "arguments", "default", "bound"],
-    visitor: ["value", "arguments"],
-    fields: {
-      name: {
-        validate: (0, _utils.assertValueType)("string")
-      },
-      value: {
-        validate: (0, _utils.assertNodeType)("Expression")
-      },
-      modifier: {
-        validate: (0, _utils.assertValueType)("string"),
-        optional: true
-      },
-      arguments: {
-        validate: (0, _utils.chain)(
-          (0, _utils.assertValueType)("array"),
-          (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "SpreadElement"))
-        ),
-        optional: true
-      },
-      default: {
-        validate: (0, _utils.assertValueType)("boolean"),
-        optional: true
-      },
-      bound: {
-        validate: (0, _utils.assertValueType)("boolean"),
-        optional: true
-      }
-    }
-  },
-
-  MarkoSpreadAttribute: {
-    aliases: ["Marko"],
-    builder: ["value"],
-    visitor: ["value"],
-    fields: {
-      value: {
-        validate: (0, _utils.assertNodeType)("Expression")
-      }
-    }
-  },
-
-  MarkoTagBody: {
-    aliases: ["Marko", "BlockParent", "FunctionParent", "Scope"],
-    builder: ["body", "params"],
-    visitor: ["typeParameters", "params", "body"],
-    fields: {
-      params: {
-        validate: (0, _utils.chain)(
-          (0, _utils.assertValueType)("array"),
-          (0, _utils.assertEach)((0, _utils.assertNodeType)("Identifier", "Pattern", "RestElement"))
-        ),
-        default: []
-      },
-      typeParameters: {
-        validate: (0, _utils.assertNodeType)("TSTypeParameterDeclaration"),
-        optional: true
-      },
-      body: {
-        validate: arrayOfType([
-        "MarkoTag",
-        "MarkoCDATA",
-        "MarkoText",
-        "MarkoPlaceholder",
-        "MarkoScriptlet",
-        "MarkoComment"]
-        ),
-        default: []
-      },
-      attributeTags: {
-        validate: (0, _utils.assertValueType)("boolean"),
-        default: false
-      }
-    }
-  },
-
-  MarkoTag: {
-    aliases: ["Marko", "Statement"],
-    builder: [
-    "name",
-    "attributes",
-    "body",
-    "arguments",
-    "var",
-    "attributeTags"],
-
-    visitor: [
-    "name",
-    "typeArguments",
-    "arguments",
-    "attributes",
-    "attributeTags",
-    "var",
-    "body"],
-
-    fields: {
-      name: {
-        validate: (0, _utils.assertNodeType)("Expression")
-      },
-      attributes: {
-        validate: arrayOfType(["MarkoAttribute", "MarkoSpreadAttribute"]),
-        default: []
-      },
-      body: {
-        validate: (0, _utils.assertNodeType)("MarkoTagBody")
-      },
-      arguments: {
-        validate: (0, _utils.chain)(
-          (0, _utils.assertValueType)("array"),
-          (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "SpreadElement"))
-        ),
-        optional: true
-      },
-      typeArguments: {
-        validate: (0, _utils.assertNodeType)("TSTypeParameterInstantiation"),
-        optional: true
-      },
-      rawValue: {
-        validate: (0, _utils.assertValueType)("string"),
-        optional: true
-      },
-      var: {
-        validate: (0, _utils.assertNodeType)("LVal"),
-        optional: true
-      },
-      attributeTags: {
-        validate: arrayOfType(["MarkoTag", "MarkoScriptlet", "MarkoComment"]),
-        default: []
-      }
-    }
-  }
-};var _default = exports.default =
-
-MarkoDefinitions;
-const MARKO_TYPES = exports.MARKO_TYPES = Object.keys(MarkoDefinitions);
-const MARKO_ALIAS_TYPES = exports.MARKO_ALIAS_TYPES = Array.from(
-  new Set(
-    MARKO_TYPES.reduce((all, t) => all.concat(MarkoDefinitions[t].aliases), [])
-  )
-);
-
-// Note this is inline because a change in babel caused a regression with this api.
-// TODO: we should not rely on babels validators or builders.
-function arrayOfType(types) {
-  return (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)(...types)));
-}

package/dist/babel-types/types/patch.js

@@ -1,124 +0,0 @@
-"use strict";var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-require("../generator/patch");
-
-var babelTypes = _interopRequireWildcard(require("@babel/types"));
-var definitionUtils = _interopRequireWildcard(require("@babel/types/lib/definitions/utils"));
-var generatedValidators = _interopRequireWildcard(require("@babel/types/lib/validators/generated"));
-var referencedValidators = _interopRequireWildcard(require("@babel/types/lib/validators/isReferenced"));
-var _validate = _interopRequireDefault(require("@babel/types/lib/validators/validate"));
-
-var _definitions = _interopRequireWildcard(require("./definitions"));function _interopRequireWildcard(e, t) {if ("function" == typeof WeakMap) var r = new WeakMap(),n = new WeakMap();return (_interopRequireWildcard = function (e, t) {if (!t && e && e.__esModule) return e;var o,i,f = { __proto__: null, default: e };if (null === e || "object" != typeof e && "function" != typeof e) return f;if (o = t ? n : r) {if (o.has(e)) return o.get(e);o.set(e, f);}for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]);return f;})(e, t);} /* eslint-disable no-import-assign */
-
-const {
-  TYPES,
-  VISITOR_KEYS,
-  FLIPPED_ALIAS_KEYS,
-  DEPRECATED_KEYS,
-  is,
-  getBindingIdentifiers
-} = babelTypes;
-
-getBindingIdentifiers.keys.Program = ["params"];
-getBindingIdentifiers.keys.MarkoTag = ["var"];
-getBindingIdentifiers.keys.MarkoTagBody = ["params"];
-getBindingIdentifiers.keys.MarkoScriptlet = ["body"];
-
-_definitions.MARKO_TYPES.forEach((typeName) => {
-  definitionUtils.default(typeName, _definitions.default[typeName]);
-});
-
-babelTypes.NODE_FIELDS.Program.params =
-babelTypes.NODE_FIELDS.MarkoTagBody.params;
-
-for (const type of [
-...Object.keys(VISITOR_KEYS),
-...Object.keys(FLIPPED_ALIAS_KEYS),
-...Object.keys(DEPRECATED_KEYS)])
-{
-  if (!TYPES.includes(type)) TYPES.push(type);
-}
-
-_definitions.MARKO_TYPES.forEach((typeName) => {
-  const lowerName = typeName[0].toLowerCase() + typeName.slice(1);
-  const checkKey = `is${typeName}`;
-  const assertKey = `assert${typeName}`;
-  babelTypes[checkKey] = (node, opts) => is(typeName, node, opts);
-  babelTypes[assertKey] = (node, opts) => assert(typeName, node, opts);
-  babelTypes[typeName] = babelTypes[lowerName] = function () {
-    return builder(typeName, arguments);
-  };
-});
-
-_definitions.MARKO_ALIAS_TYPES.forEach((aliasName) => {
-  const checkKey = `is${aliasName}`;
-  const originalCheck = generatedValidators[checkKey];
-  generatedValidators[checkKey] = (node, opts) =>
-  is(aliasName, node, opts) || originalCheck(node, opts);
-});
-
-const originalIsReferenced = referencedValidators.default;
-referencedValidators.default = (node, parent, grandparent) => {
-  switch (parent.type) {
-    case "MarkoTag":
-      return parent.var !== node;
-    case "MarkoTagBody":
-      return false;
-    default:
-      return originalIsReferenced(node, parent, grandparent);
-  }
-};
-
-for (const { types, set } of definitionUtils.allExpandedTypes || []) {
-  for (const type of types) {
-    const aliases = FLIPPED_ALIAS_KEYS[type];
-    if (aliases) {
-      aliases.forEach(set.add, set);
-    } else {
-      set.add(type);
-    }
-  }
-}
-
-function assert(typeName, node, opts) {
-  if (!is(typeName, node, opts)) {
-    throw new Error(
-      `Expected type "${typeName}" with option ${JSON.stringify(
-        opts
-      )}, but instead got "${node.type}".`
-    );
-  }
-}
-
-function builder(type, args) {
-  const definition = _definitions.default[type];
-  const keys = definition.builder;
-  const countArgs = args.length;
-  if (countArgs > keys.length) {
-    throw new Error(
-      `${type}: Too many arguments passed. Received ${countArgs} but can receive no more than ${keys.length}`
-    );
-  }
-
-  const node = { type };
-
-  for (let i = 0; i < keys.length; ++i) {
-    const key = keys[i];
-    const field = definition.fields[key];
-
-    let arg;
-    if (i < countArgs) arg = args[i];
-    if (arg === undefined) {
-      arg = Array.isArray(field.default) ? [] : field.default;
-    }
-
-    node[key] = arg;
-  }
-
-  // (assume all enumerable properties are own)
-
-  for (const key in node) {
-    (0, _validate.default)(node, key, node[key]);
-  }
-
-  return node;
-}