{"version":3,"file":"index.mjs","sources":["../../src/ast.js","../../src/validate.js","../../src/converters.js","../../src/to-markup.js"],"sourcesContent":["// -- Constants ----\n\n/**\n * Property type string for value-typed properties.\n */\nconst VALUE = 'value';\n\n/**\n * Property type string for variable-typed properties.\n */\nconst VARIABLE = 'variable';\n\n/**\n * Property type string for expression-typed properties.\n */\nconst EXPRESSION = 'expression';\n\n/**\n * Node type string for component nodes.\n */\nconst COMPONENT = 'component';\n\n/**\n * Node type string for text nodes.\n */\nconst TEXTNODE = 'textnode';\n\n/**\n * Node type string for var nodes.\n */\nconst VAR = 'var';\n\n/**\n * Node type string for derived nodes.\n */\nconst DERIVED = 'derived';\n\n/**\n * Node type string for data nodes.\n */\nconst DATA = 'data';\n\n/**\n * Node type string for meta nodes.\n */\nconst META = 'meta';\n\n// -- AST Nodes ----\n\n/**\n * Create a new AST node.\n * @param {string} name Name of the node.\n * @param {string} type Type of the node.\n * @param {object} props Properties of the node.\n * @param {object[]} children Children of the node.\n * @return {object} A new AST node.\n */\nfunction createNode(name, type, props = null, children = null) {\n  const node = { type, name };\n  if (props) {\n    node.properties = { ...props };\n  }\n  if (children) {\n    node.children = Array.from(children);\n  }\n  return node;\n}\n\n/**\n * Create a new component-typed node.\n * @param {string} name Name of the node.\n * @param {object[]} props Properties of the node.\n * @param {object[]} children Children of the node.\n * @return {object} A new component node.\n */\nfunction createComponentNode(name, props = null, children = null) {\n  return createNode(name, COMPONENT, props, children);\n}\n\n/**\n * Create a new text node.\n * @param {string} value Text content on the node.\n * @return {object} A new text node.\n */\nfunction createTextNode(value) {\n  // typeCheckString(value, 'value');\n  return { type: TEXTNODE, value };\n}\n\n/**\n * Test if a node is a text node.\n * @param {object} node The AST node.\n * @return {boolean} True if the node is a text node, false otherwise.\n */\nfunction isTextNode(node) {\n  return node.type === TEXTNODE;\n}\n\n/**\n * Test if a node is a component node.\n * @param {object} node The AST node.\n * @return {boolean} True if the node is a component node, false otherwise.\n */\nfunction isComponentNode(node) {\n  return node.type === COMPONENT;\n}\n\n/**\n * Test if a node is a variable node, one of 'var', 'derived', or 'data'.\n * @param {object} node The AST node.\n * @return {boolean} True if the node is a variable node, false otherwise.\n */\nfunction isVariableNode(node) {\n  return node.type === VAR || node.type === DERIVED || node.type === DATA;\n}\n\n/**\n * Test if a node is a meta node.\n * @param {object} node The AST node.\n * @return {boolean} True if the node is a mate node, false otherwise.\n */\nfunction isMetaNode(node) {\n  return node.type === META;\n}\n\n/**\n * Get the name of an AST node. If the node is a component, returns\n * the component name, otherwise returns the node type.\n * @param {object} node The AST node.\n * @return {string} The name of the node, or null if not defined.\n */\nfunction getNodeName(node) {\n  return isComponentNode(node) ? node.name : node.type;\n}\n\n/**\n * Get the type of an AST node.\n * @param {object} node The AST node.\n * @return {string} The type of the node, or null if not defined.\n */\nfunction getNodeType(node) {\n  return node.type || null;\n}\n\n// -- AST Node Children ----\n\n/**\n * Test if an AST node has any child nodes.\n * @param {*} node An AST node.\n * @returns {boolean} True if the node has children, false otherwise.\n */\nfunction hasChildren(node) {\n  return node.children ? node.children.length > 0 : false;\n}\n\n/**\n * Retrieve the children nodes of a parent node.\n * This method returns a direct reference to an underlying child\n * array. Callers should take care not to modify the returned array.\n * @param {object} node The parent node.\n * @return {object[]} The children of the node, or an empty array if none.\n */\nfunction getChildren(node) {\n  return node.children || [];\n}\n\n/**\n * Sets the child nodes of an AST node.\n * @param {object} node The parent node.\n * @param {object[]} children The children nodes to set.\n * @return {object} The modified AST node.\n */\nfunction setChildren(node, children) {\n  // typeCheckArray(children, 'children');\n  node.children = children;\n  return node;\n}\n\n/**\n * Append a child node to a parent node.\n * @param {object} node The parent AST node.\n * @param {object} child The child AST node to append.\n * @return {object} A modifed AST node.\n */\nfunction appendChild(node, child) {\n  return appendChildren(node, [child]);\n}\n\n/**\n * Append multiple child nodes to a parent node.\n * @param {object} node The parent AST node.\n * @param {object[]} children The children AST nodes to append.\n * @return {object} A modified AST node.\n */\nfunction appendChildren(node, children) {\n  // typeCheckArray(children, 'children');\n  const base = node.children || [];\n  node.children = base.concat(children);\n  return node;\n}\n\n/**\n * Prepend a child node to a parent node.\n * @param {object} node The parent AST node.\n * @param {object} child The child AST node to prepend.\n * @return {object} A modifed AST node.\n */\nfunction prependChild(node, child) {\n  return prependChildren(node, [child]);\n}\n\n/**\n * Prepend multiple child nodes to a parent node.\n * @param {object} node The parent AST node.\n * @param {object[]} children The children AST nodes to prepend.\n * @return {object} A modified AST node.\n */\nfunction prependChildren(node, children) {\n  // typeCheckArray(children, 'children');\n  node.children = children.concat(node.children || []);\n  return node;\n}\n\n/**\n * Filter child nodes, retaining only node that match the filter predicate.\n * @param {object} node A parent AST node.\n * @param {function(object): boolean} predicate Filter function for child nodes.\n * @return {object} The modified parent node.\n */\nfunction filterChildren(node, predicate) {\n  if (hasChildren(node)) {\n    node.children = node.children.filter(predicate);\n  }\n  return node;\n}\n\n/**\n * Modify child nodes by applying a map function to each. The results of the\n * map function become the new child nodes.\n * @param {object} node A parent AST node.\n * @param {function} mapFunc Map function applied to child nodes.\n * @return {object} The modified parent node.\n */\nfunction mapChildren(node, mapFunc) {\n  if (hasChildren(node)) {\n    node.children = node.children.map(mapFunc);\n  }\n  return node;\n}\n\n// -- AST Node Properties ----\n\nfunction hasKeys(object) {\n  for (const key in object) return true;\n  return false;\n}\n\n/**\n * Tests if an AST node has any defined properties.\n * @param {*} node The AST node.\n * @returns {boolean} True is the node has properties, false otherwise.\n */\nfunction hasProperties(node) {\n  return hasKeys(node.properties);\n}\n\n/**\n * Retrieves the properties object for an AST node.\n * @param {object} node The AST node.\n * @returns {object} The properties object, or null if none.\n */\nfunction getProperties(node) {\n  return node.properties || null;\n}\n\n/**\n * Add a set of properties to an AST node. Any existing\n * properties with matching keys will be overwritten.\n * @param {object} node The AST node.\n * @param {object} properties A properties object. Object keys are\n *  property names, object values must be property data objects.\n * @returns {object} The modified AST node.\n */\nfunction setProperties(node, properties) {\n  for (const key in properties) {\n    setProperty(node, key, properties[key]);\n  }\n  return node;\n}\n\n/**\n * Remove all properties from an AST node.\n * @param {object} node The AST node.\n * @returns {object} The modified AST node.\n */\nfunction clearProperties(node) {\n  delete node.properties;\n  return node;\n}\n\n/**\n * Retrieves an array of property keys for a node.\n * @param {object} node The AST node.\n * @return {string[]} The property keys, or an empty array if none.\n */\nfunction getPropertyKeys(node) {\n  return Object.keys(node.properties || {});\n}\n\n/**\n * Retrieves the property type for a node property.\n * @param {object} node The AST node.\n * @param {string} key The property key.\n * @return {string} The property type, or null if the property is not defined.\n */\nfunction getPropertyType(node, key) {\n  const prop = getProperty(node, key);\n  return (prop && prop.type) || null;\n}\n\n/**\n * Retrieves the property value for a node property.\n * @param {object} node The AST node.\n * @param {string} key The property key.\n * @return {string} The property value, or null if the property is not defined.\n */\nfunction getPropertyValue(node, key) {\n  const prop = getProperty(node, key);\n  return (prop && prop.value) || null;\n}\n\n/**\n * Test if a property with the given key is defined on a node.\n * @param {object} node The AST node.\n * @param {string} key The property key.\n * @return {boolean} True if the property is defined, else false.\n */\nfunction hasProperty(node, key) {\n  return (node.properties && node.properties.hasOwnProperty(key)) || false;\n}\n\n/**\n * Retrieves a property of a node given its key.\n * @param {object} node The AST node.\n * @param {string} key The property key.\n * @return {object} The property data, or null if the property does not exist.\n */\nfunction getProperty(node, key) {\n  return hasProperty(node, key) ? node.properties[key] : null;\n}\n\n/**\n * Set a property of a node.\n * @param {object} node The AST node.\n * @param {string} key The property key.\n * @param {object} data The property data, should\n *  be an object with type and value properties.\n * @return {object} The modfied AST node.\n */\nfunction setProperty(node, key, data) {\n  // TODO: type checking of property data?\n  if (!node.properties) {\n    node.properties = {};\n  }\n  node.properties[key] = data;\n  return node;\n}\n\n/**\n * Set a value-typed property of a node.\n * @param {object} node The AST node.\n * @param {string} key The property key.\n * @param {*} value The property value.\n * @return {object} The modfied AST node.\n */\nfunction setValueProperty(node, key, value) {\n  return setProperty(node, key, { type: VALUE, value });\n}\n\n/**\n * Set a variable-typed property of a node.\n * @param {object} node The AST node.\n * @param {string} key The property key.\n * @param {string} value A reactive variable name.\n * @return {object} The modfied AST node.\n */\nfunction setVariableProperty(node, key, value) {\n  return setProperty(node, key, { type: VARIABLE, value });\n}\n\n/**\n * Set an expression-typed property of a node.\n * @param {object} node The AST node.\n * @param {string} key The property key.\n * @param {string} value A JavaScript expression string.\n * @return {object} The modfied AST node.\n */\nfunction setExpressionProperty(node, key, value) {\n  return setProperty(node, key, { type: EXPRESSION, value });\n}\n\n/**\n * Remove a property of a node.\n * @param {object} node The AST node.\n * @param {string} key The property key.\n * @return {object} The modified AST node.\n */\nfunction removeProperty(node, key) {\n  if (hasProperty(node, key)) {\n    const { [key]: remove, ...props } = node.properties;\n    if (hasKeys(props)) {\n      node.properties = props;\n    } else {\n      delete node.properties;\n    }\n  }\n  return node;\n}\n\n// -- AST Traversal ----\n\n/**\n * Perform a preorder depth-first traversal of the AST.\n * @param {object} node The AST node at which to begin the traversal.\n * @param {function} callack Callback function invoked for each visited node.\n */\nfunction cloneNode(node) {\n  const clone = { ...node };\n  if (clone.properties) {\n    clone.properties = { ...clone.properties };\n  }\n  if (clone.children) {\n    clone.children = clone.children.map(child => cloneNode(child));\n  }\n  return clone;\n}\n\n/**\n * Perform a preorder depth-first traversal of the AST.\n * @param {object} node The AST node at which to begin the traversal.\n * @param {function} callack Callback function invoked for each visited node.\n */\nfunction visitNodes(node, callback) {\n  callback(node);\n  getChildren(node).forEach(node => visitNodes(node, callback));\n}\n\n/**\n * Retrieve all nodes that match a given predicate function.\n * @param {object} node The AST node at which to begin searching.\n *  Only this node and its descendants are considered.\n * @param {function(object): boolean} predicate Filter function to test nodes.\n *  If the predicate returns true, the node is included in the result.\n * @returns {object[]} An array of AST nodes that match the predicate.\n */\nfunction queryNodes(node, predicate) {\n  const nodes = [];\n\n  visitNodes(node, n => {\n    if (predicate(n)) {\n      nodes.push(n);\n    }\n  });\n\n  return nodes;\n}\n\n/**\n * Extract the text from all text nodes under an AST node.\n * @param {object} ast The AST node.\n * @return {string} The extracted text, concatenated into strings.\n */\nfunction extractText(node) {\n  const texts = [];\n  visitNodes(node, n => {\n    if (isTextNode(n)) {\n      texts.push(n.value);\n    }\n  });\n  return texts.join(' ');\n}\n\n/**\n * Remove any descendant nodes that match a given predicate function.\n * @param {object} node The AST node at which to begin searching.\n *  Only descendants of this node are considered for removal.\n * @param {function(object): boolean} predicate Filter function to test nodes.\n *  If the predicate returns true, the node is removed from the AST.\n * @returns {object} The AST node width descendants removed.\n */\nfunction removeNodes(node, predicate) {\n  if (hasChildren(node)) {\n    node.children = node.children.filter(child => {\n      if (predicate(child)) {\n        return false;\n      } else {\n        removeNodes(child, predicate);\n        return true;\n      }\n    });\n  }\n  return node;\n}\n\nexport {\n  VALUE,\n  VARIABLE,\n  EXPRESSION,\n  COMPONENT,\n  TEXTNODE,\n  VAR,\n  DERIVED,\n  DATA,\n  META,\n  createNode,\n  createComponentNode,\n  createTextNode,\n  isTextNode,\n  isComponentNode,\n  isVariableNode,\n  isMetaNode,\n  getNodeName,\n  getNodeType,\n  hasChildren,\n  getChildren,\n  setChildren,\n  appendChild,\n  appendChildren,\n  prependChild,\n  prependChildren,\n  filterChildren,\n  mapChildren,\n  hasProperties,\n  getProperties,\n  setProperties,\n  clearProperties,\n  getPropertyKeys,\n  getPropertyType,\n  getPropertyValue,\n  hasProperty,\n  getProperty,\n  setProperty,\n  setValueProperty,\n  setVariableProperty,\n  setExpressionProperty,\n  removeProperty,\n  cloneNode,\n  visitNodes,\n  queryNodes,\n  extractText,\n  removeNodes\n};\n","import schema from './ast.schema.json';\nimport Ajv from 'ajv';\nimport metaSchema from 'ajv/lib/refs/json-schema-draft-06.json';\n\nconst ajv = new Ajv();\najv.addMetaSchema(metaSchema);\n\nlet astValidator;\nlet propValidator;\n\nclass MalformedASTError extends Error {\n  constructor(msg, errors) {\n    super(msg);\n    this.name = this.constructor.name;\n    this.message = msg;\n    this.stack = new Error(msg).stack;\n  }\n}\n\n/**\n * Validates if an AST node conforms to the JSON schema.\n * @param {object} node The AST node.\n * @throws Error if AST validation fails.\n */\nfunction validateNode(ast) {\n  if (!astValidator) {\n    astValidator = ajv.compile(schema);\n  }\n  if (!astValidator(ast)) {\n    throw new MalformedASTError(\n      'AST node does not match schema: ' + astValidator.errors[0].message\n    );\n  }\n}\n\n/**\n * Validates if AST node properties conform to the JSON schema.\n * @param {object} properties An AST node properties object.\n * @throws Error if AST validation fails.\n */\nfunction validateProperties(properties) {\n  if (!propValidator) {\n    propValidator = ajv.compile(schema.properties.properties);\n  }\n  if (!propValidator(properties)) {\n    throw new MalformedASTError(\n      'AST properties do not match schema: ' + propValidator.errors[0].message\n    );\n  }\n}\n\nexport { validateNode, validateProperties };\n","/*\nTHIS FILE CONTAINS THE CONVERTER FUNCTIONS FOR THE TWO DIFFERENT TYPES OF AST STRUCTURE.\n*/\n\n/**\n * This function converts the JSON structured AST (ASTV2) to the array structured\n * AST (OLD AST)\n * @param {*} jsonAst\n * @return Array structred AST\n */\nconst convertV2ToV1 = jsonAst => {\n  let arrayAst = [];\n  if (jsonAst.children) {\n    jsonAst.children.forEach(element => {\n      arrayAst.push(convertHelper(element));\n    });\n  }\n  return arrayAst;\n};\n\n/**\n * Helper function for convert\n * @param {*} jsonElement\n * @return array representation of the corresponding jsonElement\n */\nfunction convertHelper(jsonElement) {\n  let elementArray = [];\n  if (jsonElement.type === 'textnode') {\n    return jsonElement.value;\n  } else if (jsonElement.type === 'var' || jsonElement.type === 'derived') {\n    elementArray = [jsonElement.type];\n    elementArray.push([\n      ['name', ['value', jsonElement.name]],\n      ['value', ['value', jsonElement.value]]\n    ]);\n    elementArray.push([]);\n  } else if (jsonElement.type === 'data') {\n    elementArray = ['data'];\n    elementArray.push([\n      ['name', ['value', jsonElement.name]],\n      ['source', ['value', jsonElement.source]],\n      ['async', ['value', jsonElement.async]],\n      ['initialValue', ['expression', jsonElement.initialValue]]\n    ]);\n    elementArray.push([]);\n  } else {\n    elementArray.push(jsonElement.name);\n    let propertiesArray = [];\n    if ('properties' in jsonElement) {\n      Object.keys(jsonElement.properties).forEach(key => {\n        let propertyArray = [key];\n        propertyArray.push([\n          jsonElement.properties[key].type,\n          jsonElement.properties[key].value\n        ]);\n        propertiesArray.push(propertyArray);\n      });\n    }\n    elementArray.push(propertiesArray);\n    if ('children' in jsonElement) {\n      let childArray = [];\n      jsonElement.children.forEach(children => {\n        childArray.push(convertHelper(children));\n      });\n      elementArray.push(childArray);\n    }\n  }\n  return elementArray;\n}\n\n/**\n * This function converts the array structred AST (OLD AST) to the new\n * JSON structured ast(ASTV2)\n * @param {*} arrayAst\n * @return Json structred ast correspoding to the arrayAst.\n */\nconst convertV1ToV2 = (arrayAst, injectIds) => {\n  let _id = 0;\n  const id = injectIds ? () => _id++ : null;\n\n  const jsonAst = new Object();\n  if (id) jsonAst.id = id();\n  jsonAst.type = 'component';\n  jsonAst.name = 'div';\n  jsonAst.children = arrayAst.map(element => inverseConvertHelper(element, id));\n\n  return jsonAst;\n};\n\n/**\n * Helper function for inverseConvert\n * @param {*} arrayElement\n * @return JSON representation of the corresponding arrayElement\n */\nfunction inverseConvertHelper(arrayElement, id) {\n  let elementJson = new Object();\n  if (id) elementJson.id = id();\n\n  if (typeof arrayElement === 'string') {\n    elementJson.type = 'textnode';\n    elementJson.value = arrayElement;\n  } else if (['var', 'derived', 'data', 'meta'].indexOf(arrayElement[0]) > -1) {\n    elementJson.type = arrayElement[0];\n    elementJson.properties = {};\n    arrayElement[1].forEach(property => {\n      elementJson.properties[property[0]] = {\n        type: property[1][0],\n        value: property[1][1]\n      };\n    });\n  } else {\n    elementJson.type = 'component';\n    elementJson.name = arrayElement[0];\n    if (arrayElement[1].length !== 0) {\n      elementJson.properties = {};\n      arrayElement[1].forEach(property => {\n        elementJson.properties[property[0]] = {\n          type: property[1][0],\n          value: property[1][1]\n        };\n      });\n    }\n    if (arrayElement[2]) {\n      elementJson.children = arrayElement[2].map(element =>\n        inverseConvertHelper(element, id)\n      );\n    }\n  }\n\n  return elementJson;\n}\n\nexport { convertV1ToV2, convertV2ToV1 };\n","import htmlTags from 'html-tags';\nimport {\n  VALUE,\n  EXPRESSION,\n  VARIABLE,\n  getChildren,\n  hasChildren,\n  isComponentNode\n} from './ast';\n\n/**\n * Convert an AST to valid Idyll markup.\n * @param {object} node The AST node.\n * @return {string} The markup string.\n */\nfunction toMarkup(node, options = { insertFullWidth: false }) {\n  const markup = childrenToMarkup(\n    node,\n    0,\n    node.name === 'p' ? ' ' : '\\n',\n    options.insertFullWidth || false\n  ).trim();\n\n  const cleanedMarkup = markup.replace(/([\\]\\*\\_]) ([,\\.\\!\\?\\:\\[])/g, '$1$2');\n\n  return cleanedMarkup;\n}\n\nfunction childrenToMarkup(\n  node,\n  depth,\n  separator = '\\n',\n  insertFullWidth = false\n) {\n  let markup = '';\n  for (const child of getChildren(node)) {\n    markup +=\n      separator + nodeToMarkup(child, depth, separator, insertFullWidth);\n  }\n  return markup.replace(/\\n\\n+/g, '\\n\\n');\n}\n\nfunction nodeToMarkup(node, depth, separator = '\\n', insertFullWidth = false) {\n  let name = (node.name && node.name.toLowerCase()) || null;\n\n  if (name === 'idylleditordroptarget') {\n    return '';\n  }\n\n  const markupNodes = [\n    'strong',\n    'em',\n    'i',\n    'b',\n    'code',\n    'h1',\n    'h2',\n    'h3',\n    'h4',\n    'h5',\n    'a'\n  ];\n\n  // normalize component names\n  if (name && !htmlTags.includes(name)) {\n    node.name = node.name\n      .split('-')\n      .map(s => s.charAt(0).toUpperCase() + s.slice(1))\n      .join('');\n    name = node.name.toLowerCase();\n  }\n\n  switch (node.type) {\n    case 'textnode':\n      return `${'  '.repeat(depth)}${node.value.trim()}`;\n    case 'component':\n      if (name === 'textcontainer') {\n        return `\\n${childrenToMarkup(node, depth, '\\n', false)}`;\n      } else if (name === 'p' && depth < 1) {\n        return `\\n${childrenToMarkup(node, depth, '\\n', false).trim()}\\n`;\n      } else if (markupNodes.includes(name)) {\n        switch (name) {\n          case 'strong':\n          case 'b':\n            return `**${childrenToMarkup(node, 0, ' ', false).trim()}**`;\n          case 'em':\n          case 'i':\n            return `*${childrenToMarkup(node, 0, ' ', false).trim()}*`;\n          case 'code':\n            return `\\`${childrenToMarkup(node, 0, ' ', false).trim()}\\``;\n          case 'h1':\n          case 'h2':\n          case 'h3':\n          case 'h4':\n          case 'h5':\n            if (\n              node.children &&\n              node.children.length === 1 &&\n              node.children[0].type === 'textnode'\n            ) {\n              return `${'#'.repeat(+node.name[1])} ${childrenToMarkup(\n                node,\n                0,\n                ' ',\n                false\n              ).trim()}`;\n            }\n        }\n      }\n\n      if (\n        name === 'pre' &&\n        node.children &&\n        node.children.length === 1 &&\n        node.children[0].name &&\n        node.children[0].name.toLowerCase() === 'code'\n      ) {\n        return `\n\\`\\`\\`\n${childrenToMarkup(node.children[0], 0, ' ', false).trim()}\n\\`\\`\\`\n        `;\n      } else if (\n        name === 'pre' &&\n        node.children &&\n        node.children.length === 1 &&\n        node.children[0].type === 'textnode'\n      ) {\n        return `\n\\`\\`\\`\n${childrenToMarkup(node, 0, ' ', false).trim()}\n\\`\\`\\``;\n      }\n\n      const propString = propertiesToString(node, depth, insertFullWidth);\n      if (hasChildren(node)) {\n        if (name === 'a') {\n          return `${'  '.repeat(depth)}[${node.name}${\n            propString ? `${propString}` : ''\n          }]${childrenToMarkup(node, depth + 1, ' ', false).trim()}[/${\n            node.name\n          }]`;\n        }\n        return `${'  '.repeat(depth)}[${node.name}${\n          propString ? `${propString}` : ''\n        }]${childrenToMarkup(node, depth + 1, separator, false)}\\n${'  '.repeat(\n          depth\n        )}[/${node.name}]`;\n      }\n      return `${'  '.repeat(depth)}[${node.name}${\n        propString ? `${propString}` : ''\n      } /]`;\n    case 'var':\n    case 'derived':\n    case 'data':\n    case 'meta':\n      return `${'  '.repeat(depth)}[${node.type}${propertiesToString(\n        node,\n        depth,\n        insertFullWidth\n      )} /]`;\n  }\n}\n\nfunction propertiesToString(node, depth, insertFullWidth) {\n  const props = { ...node.properties };\n  if (\n    insertFullWidth &&\n    isComponentNode(node) &&\n    node.name.toLowerCase() !== 'textcontainer'\n  ) {\n    props.fullWidth = { type: 'value', value: true };\n  }\n\n  let flatString = Object.keys(props || {}).reduce(\n    (memo, key) => memo + ` ${key}:${propertyToString(props[key])}`,\n    ''\n  );\n\n  if (flatString.length < 60) {\n    return flatString;\n  }\n\n  return Object.keys(props || {}).reduce(\n    (memo, key) =>\n      memo +\n      `\\n${'  '.repeat(depth + 1)}${key}:${propertyToString(props[key])}`,\n    ''\n  );\n}\n\nfunction propertyToString(property) {\n  switch (property.type) {\n    case VALUE:\n      return JSON.stringify(property.value);\n    case EXPRESSION:\n      return `\\`${property.value}\\``;\n    case VARIABLE:\n      return property.value;\n  }\n}\n\nexport { toMarkup };\n"],"names":["VALUE","VARIABLE","EXPRESSION","COMPONENT","TEXTNODE","VAR","DERIVED","DATA","META","createNode","name","type","props","children","node","properties","_objectSpread","Array","from","createComponentNode","createTextNode","value","isTextNode","isComponentNode","isVariableNode","isMetaNode","getNodeName","getNodeType","hasChildren","length","getChildren","setChildren","appendChild","child","appendChildren","base","concat","prependChild","prependChildren","filterChildren","predicate","filter","mapChildren","mapFunc","map","hasKeys","object","key","hasProperties","getProperties","setProperties","setProperty","clearProperties","getPropertyKeys","Object","keys","getPropertyType","prop","getProperty","getPropertyValue","hasProperty","hasOwnProperty","data","setValueProperty","setVariableProperty","setExpressionProperty","removeProperty","cloneNode","clone","visitNodes","callback","forEach","queryNodes","nodes","n","push","extractText","texts","join","removeNodes","ajv","Ajv","addMetaSchema","metaSchema","astValidator","propValidator","MalformedASTError","msg","errors","constructor","message","stack","Error","validateNode","ast","compile","schema","validateProperties","convertV2ToV1","jsonAst","arrayAst","element","convertHelper","jsonElement","elementArray","source","async","initialValue","propertiesArray","propertyArray","childArray","convertV1ToV2","injectIds","_id","id","inverseConvertHelper","arrayElement","elementJson","indexOf","property","toMarkup","options","insertFullWidth","markup","childrenToMarkup","trim","cleanedMarkup","replace","depth","separator","nodeToMarkup","toLowerCase","markupNodes","htmlTags","includes","split","s","charAt","toUpperCase","slice","repeat","propString","propertiesToString","fullWidth","flatString","reduce","memo","propertyToString","JSON","stringify"],"mappings":"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"}