@marko/compiler 5.39.49 → 5.39.51

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,122 +0,0 @@
-"use strict";var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-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;
-}