@marko/compiler 5.20.9 → 5.21.2

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/babel-types/generator/patch.js"],"names":["UNENCLOSED_WHITESPACE_TYPES","Object","assign","Printer","prototype","MarkoDocumentType","node","token","value","MarkoDeclaration","MarkoCDATA","MarkoComment","MarkoPlaceholder","parent","parentBody","body","prev","indexOf","t","isMarkoText","isMarkoPlaceholder","removeTrailingNewline","escape","print","MarkoScriptlet","isProgram","static","length","newline","indent","printSequence","dedent","MarkoClass","MarkoAttribute","default","name","modifier","arguments","printList","isBooleanLiteral","isFunctionExpression","id","async","generator","params","bound","printWithParansIfNeeded","call","MarkoSpreadAttribute","MarkoText","concatToPrev","isMultiLine","test","isRootLevel","word","MarkoTagBody","MarkoTag","isDynamicTag","isStringLiteral","tagName","rawValue","var","attributes","printJoin","separator","spaceSeparator","SELF_CLOSING","voidElements","includes","svgElements","needsParans","hasUnenclosedWhitespace","type"],"mappings":"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","sourcesContent":["import \"../types/patch\";\n\nimport * as t from \"@babel/types\";\nimport SELF_CLOSING from \"self-closing-tags\";\nimport Printer from \"@babel/generator/lib/printer\";\n\nconst UNENCLOSED_WHITESPACE_TYPES = [\n  \"LogicalExpression\",\n  \"AssignmentExpression\",\n  \"ConditionalExpression\",\n  \"BinaryExpression\",\n  \"NewExpression\",\n  \"Function\",\n  \"AssignmentExpression\"\n];\n\nObject.assign(Printer.prototype, {\n  MarkoDocumentType(node) {\n    this.token(\"<!\");\n    this.token(node.value);\n    this.token(\">\");\n  },\n  MarkoDeclaration(node) {\n    this.token(\"<?\");\n    this.token(node.value);\n    this.token(\"?>\");\n  },\n  MarkoCDATA(node) {\n    this.token(\"<![CDATA[\");\n    this.token(node.value);\n    this.token(\"]]>\");\n  },\n  MarkoComment(node) {\n    this.token(\"<!--\");\n    this.token(node.value);\n    this.token(\"-->\");\n  },\n  MarkoPlaceholder(node, parent) {\n    if (parent) {\n      const parentBody = parent.body;\n      const prev = parentBody[parentBody.indexOf(node) - 1];\n\n      if (prev && (t.isMarkoText(prev) || t.isMarkoPlaceholder(prev))) {\n        this.removeTrailingNewline();\n      }\n    }\n\n    this.token(node.escape ? \"${\" : \"$!{\");\n    this.print(node.value, node);\n    this.token(\"}\");\n  },\n  MarkoScriptlet(node, parent) {\n    this.removeTrailingNewline();\n\n    if (!(t.isProgram(parent) && parent.body.indexOf(node) === 0)) {\n      this.token(\"\\n\");\n    }\n\n    this.token(`${node.static ? \"static\" : \"$\"} `);\n\n    if (node.body.length === 1) {\n      // TODO should determine if node has unenclosed newlines.\n      this.print(node.body[0], node);\n    } else {\n      this.token(\"{\");\n      this.newline();\n      this.indent();\n      this.printSequence(node.body, node);\n      this.dedent();\n      this.token(\"}\");\n    }\n  },\n  MarkoClass(node) {\n    this.token(\"class\");\n    this.token(\" \");\n    this.print(node.body, node);\n  },\n  MarkoAttribute(node) {\n    const value = node.value;\n\n    if (!node.default) {\n      this.token(node.name);\n\n      if (node.modifier) {\n        this.token(\":\");\n        this.token(node.modifier);\n      }\n\n      if (node.arguments && node.arguments.length) {\n        this.token(\"(\");\n        this.printList(node.arguments, node);\n        this.token(\")\");\n      }\n    }\n\n    if (node.default || !t.isBooleanLiteral(value, { value: true })) {\n      if (\n        t.isFunctionExpression(value) &&\n        !(value.id || value.async || value.generator)\n      ) {\n        this.token(\"(\");\n        this.printList(value.params, value);\n        this.token(\") \");\n        this.print(value.body, value);\n      } else {\n        this.token(node.bound ? \":=\" : \"=\");\n        printWithParansIfNeeded.call(this, value, node);\n      }\n    }\n  },\n  MarkoSpreadAttribute(node) {\n    this.token(\"...\");\n    printWithParansIfNeeded.call(this, node.value, node);\n  },\n  MarkoText(node, parent) {\n    const parentBody = parent.body;\n    const prev = parentBody[parentBody.indexOf(node) - 1];\n    const concatToPrev = prev && t.isMarkoPlaceholder(prev);\n    let { value } = node;\n\n    if (concatToPrev) {\n      this.removeTrailingNewline();\n    }\n\n    const isMultiLine = /[\\r\\n]/g.test(value);\n    const isRootLevel = !concatToPrev && t.isProgram(parent);\n\n    if (isRootLevel) {\n      if (isMultiLine) {\n        this.token(\"---\\n\");\n      } else {\n        this.token(\"-- \");\n      }\n    }\n\n    this.word(value);\n\n    if (isMultiLine && isRootLevel) {\n      this.token(\"\\n---\");\n    }\n  },\n  MarkoTagBody(node) {\n    this.printSequence(node.body, node, { indent: true });\n  },\n  MarkoTag(node) {\n    const isDynamicTag = !t.isStringLiteral(node.name);\n    const tagName = !isDynamicTag && node.name.value;\n    const rawValue = node.rawValue;\n\n    if (\n      tagName === \"style\" &&\n      /^style(?:\\.[^\\s]+)?\\s*\\{[\\s\\S]*}$/.test(rawValue)\n    ) {\n      this.token(rawValue);\n      return;\n    }\n\n    this.token(\"<\");\n\n    if (rawValue) {\n      this.token(rawValue);\n    } else {\n      if (isDynamicTag) {\n        this.token(\"${\");\n        this.print(node.name, node);\n        this.token(\"}\");\n      } else {\n        this.token(tagName);\n      }\n\n      if (node.var) {\n        this.token(\"/\");\n        this.print(node.var, node);\n      }\n\n      if (node.arguments && node.arguments.length) {\n        this.token(\"(\");\n        this.printList(node.arguments, node);\n        this.token(\")\");\n      }\n\n      if (node.body.params.length) {\n        this.token(\"|\");\n        this.printList(node.body.params, node);\n        this.token(\"|\");\n      }\n\n      if (node.attributes.length) {\n        if (\n          !(node.attributes && node.attributes[0] && node.attributes[0].default)\n        ) {\n          this.token(\" \");\n        }\n\n        this.printJoin(node.attributes, node, { separator: spaceSeparator });\n      }\n    }\n\n    if (SELF_CLOSING.voidElements.includes(tagName)) {\n      this.token(\">\");\n    } else if (\n      !node.body.body.length ||\n      SELF_CLOSING.svgElements.includes(tagName)\n    ) {\n      this.token(\"/>\");\n    } else {\n      this.token(\">\");\n      this.newline();\n      this.print(node.body, node);\n      this.token(\"</\");\n      if (!isDynamicTag) {\n        this.token(tagName);\n      }\n      this.token(\">\");\n    }\n  }\n});\n\nfunction spaceSeparator() {\n  this.token(\" \");\n}\n\nfunction printWithParansIfNeeded(value, parent) {\n  const needsParans = hasUnenclosedWhitespace(value);\n\n  if (needsParans) {\n    this.token(\"(\");\n  }\n\n  this.print(value, parent);\n\n  if (needsParans) {\n    this.token(\")\");\n  }\n}\n\nfunction hasUnenclosedWhitespace(node) {\n  return UNENCLOSED_WHITESPACE_TYPES.includes(node.type);\n}\n"],"file":"patch.js"}

package/dist/babel-types/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/babel-types/index.js"],"names":[],"mappings":"6GAAA;AACA;AACA;AACA;AACA,kD","sourcesContent":["import \"./types/patch\";\nimport \"./traverse/patch\";\nimport \"./generator/patch\";\nexport * from \"@babel/types\";\nexport { MARKO_TYPES } from \"./types/definitions\";\n"],"file":"index.js"}

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/babel-types/traverse/patch.js"],"names":["MARKO_TYPES","forEach","typeName","checkKey","assertKey","checkFn","t","assertFn","NodePath","prototype","opts","node","MARKO_ALIAS_TYPES","aliasName","originalProtoCheck","is","call","originalCrawl","Scope","crawl","patchedVisitors","WeakSet","path","originalTraverse","traverse","visitor","state","hoistableTagVarsByScope","Map","has","add","Object","assign","explode","MarkoTagBody","body","param","get","scope","registerBinding","MarkoTag","tag","tagVar","name","getBindingIdentifiers","curScope","binding","getBinding","parent","hoistableTagVars","set","references","length","movedBindings","ref","hasBinding","hoistableBinding","buildCodeFrameError","movedBinding","getScopeDepth","moveBindingTo","identifier","depth","cur"],"mappings":"aAAA;;AAEA;AACA;AACA,mD;;AAEAA,yBAAYC,OAAZ,CAAoB,CAAAC,QAAQ,KAAI;AAC9B,QAAMC,QAAQ,GAAI,KAAID,QAAS,EAA/B;AACA,QAAME,SAAS,GAAI,SAAQF,QAAS,EAApC;AACA,QAAMG,OAAO,GAAGC,CAAC,CAACH,QAAD,CAAjB;AACA,QAAMI,QAAQ,GAAGD,CAAC,CAACF,SAAD,CAAlB;AACAI,qBAASC,SAAT,CAAmBN,QAAnB,IAA+B,UAAUO,IAAV,EAAgB;AAC7C,WAAOL,OAAO,CAAC,KAAKM,IAAN,EAAYD,IAAZ,CAAd;AACD,GAFD;AAGAF,qBAASC,SAAT,CAAmBL,SAAnB,IAAgC,UAAUM,IAAV,EAAgB;AAC9CH,IAAAA,QAAQ,CAAC,KAAKI,IAAN,EAAYD,IAAZ,CAAR;AACD,GAFD;AAGD,CAXD;;AAaAE,+BAAkBX,OAAlB,CAA0B,CAAAY,SAAS,KAAI;AACrC,QAAMV,QAAQ,GAAI,KAAIU,SAAU,EAAhC;AACA,QAAMC,kBAAkB,GAAGN,mBAASC,SAAT,CAAmBN,QAAnB,CAA3B;AACAK,qBAASC,SAAT,CAAmBN,QAAnB,IAA+B,UAAUO,IAAV,EAAgB;AAC7C;AACEJ,MAAAA,CAAC,CAACS,EAAF,CAAKF,SAAL,EAAgB,KAAKF,IAArB,EAA2BD,IAA3B;AACAI,MAAAA,kBAAkB,CAACE,IAAnB,CAAwB,IAAxB,EAA8B,KAAKL,IAAnC,EAAyCD,IAAzC,CAFF;;AAID,GALD;AAMD,CATD;;AAWA;AACA;AACA,MAAMO,aAAa,GAAGC,gBAAMT,SAAN,CAAgBU,KAAtC;AACA,MAAMC,eAAe,GAAG,IAAIC,OAAJ,EAAxB;;AAEAH,gBAAMT,SAAN,CAAgBU,KAAhB,GAAwB,YAAY;AAClC,QAAMG,IAAI,GAAG,KAAKA,IAAlB;AACA,QAAMC,gBAAgB,GAAGD,IAAI,CAACE,QAA9B;AACAF,EAAAA,IAAI,CAACE,QAAL,GAAgB,UAAUC,OAAV,EAAmBC,KAAnB,EAA0B;AACxCA,IAAAA,KAAK,CAACC,uBAAN,GAAgC,IAAIC,GAAJ,EAAhC;AACAN,IAAAA,IAAI,CAACE,QAAL,GAAgBD,gBAAhB;;AAEA,QAAI,CAACH,eAAe,CAACS,GAAhB,CAAoBJ,OAApB,CAAL,EAAmC;AACjCL,MAAAA,eAAe,CAACU,GAAhB,CAAoBL,OAApB;AACAM,MAAAA,MAAM,CAACC,MAAP;AACER,wBAASS,OAAT,CAAiBR,OAAjB,CADF;AAEED,wBAASS,OAAT,CAAiB;AACfC,QAAAA,YAAY,CAACC,IAAD,EAAO;AACjB,eAAK,MAAMC,KAAX,IAAoBD,IAAI,CAACE,GAAL,CAAS,QAAT,CAApB,EAAwC;AACtCF,YAAAA,IAAI,CAACG,KAAL,CAAWC,eAAX,CAA2B,OAA3B,EAAoCH,KAApC;AACD;AACF,SALc;AAMfI,QAAAA,QAAQ,CAACC,GAAD,EAAMf,KAAN,EAAa;AACnB,gBAAMgB,MAAM,GAAGD,GAAG,CAACJ,GAAJ,CAAQ,KAAR,CAAf;AACA,cAAIK,MAAM,CAAC/B,IAAX,EAAiB;AACf8B,YAAAA,GAAG,CAACH,KAAJ,CAAUC,eAAV,CAA0B,OAA1B,EAAmCG,MAAnC,EAA2CD,GAA3C;AACA,iBAAK,MAAME,IAAX,IAAmBD,MAAM,CAACE,qBAAP,EAAnB,EAAmD;AACjD,kBAAIC,QAAQ,GAAGJ,GAAG,CAACH,KAAnB;AACA,oBAAMQ,OAAO,GAAGD,QAAQ,CAACE,UAAT,CAAoBJ,IAApB,CAAhB;;AAEA,qBAAQE,QAAQ,GAAGA,QAAQ,CAACG,MAA5B,EAAqC;AACnC,sBAAMC,gBAAgB;AACpBvB,gBAAAA,KAAK,CAACC,uBAAN,CAA8BU,GAA9B,CAAkCQ,QAAlC,CADF;;AAGA,oBAAII,gBAAJ,EAAsB;AACpBA,kBAAAA,gBAAgB,CAACN,IAAD,CAAhB,GAAyBM,gBAAgB,CAACN,IAAD,CAAhB;AACrB,sBADqB;AAErBG,kBAAAA,OAFJ;AAGD,iBAJD,MAIO;AACLpB,kBAAAA,KAAK,CAACC,uBAAN,CAA8BuB,GAA9B,CAAkCL,QAAlC,EAA4C;AAC1C,qBAACF,IAAD,GAAQG,OADkC,EAA5C;;AAGD;AACF;AACF;AACF;AACF,SA9Bc,EAAjB,CAFF;;;AAmCD;;AAED,SAAKtB,QAAL,CAAcC,OAAd,EAAuBC,KAAvB;;AAEA,QAAIA,KAAK,CAACyB,UAAN,CAAiBC,MAArB,EAA6B;AAC3B,YAAMC,aAAa,GAAG,IAAIzB,GAAJ,EAAtB;AACA,WAAK,MAAM0B,GAAX,IAAkB5B,KAAK,CAACyB,UAAxB,EAAoC;AAClC,cAAM,EAAER,IAAF,KAAWW,GAAG,CAAC3C,IAArB;AACA,YAAIkC,QAAQ,GAAGS,GAAG,CAAChB,KAAnB;AACA,YAAIO,QAAQ,CAACU,UAAT,CAAoBZ,IAApB,CAAJ,EAA+B;;AAE/B,WAAG;AACD,gBAAMa,gBAAgB;AACpB9B,UAAAA,KAAK,CAACC,uBAAN,CAA8BU,GAA9B,CAAkCQ,QAAlC,CADoB,qBACpB,sBAA8CF,IAA9C,CADF;;AAGA,cAAIa,gBAAJ,EAAsB;AACpB,gBAAIA,gBAAgB,KAAK,IAAzB,EAA+B;AAC7B,oBAAMF,GAAG,CAACG,mBAAJ;AACJ,kGADI,CAAN;;AAGD;;AAED,kBAAMC,YAAY,GAAGL,aAAa,CAAChB,GAAd,CAAkBmB,gBAAlB,CAArB;AACA;AACE,aAACE,YAAD;AACAC,YAAAA,aAAa,CAACD,YAAD,CAAb,GAA8BC,aAAa,CAACd,QAAD,CAF7C;AAGE;AACAQ,cAAAA,aAAa,CAACH,GAAd,CAAkBM,gBAAlB,EAAoCX,QAApC;AACD;AACF;AACF,SAnBD,QAmBUA,QAAQ,GAAGA,QAAQ,CAACG,MAnB9B;AAoBD;;AAED,WAAK,MAAM,CAACF,OAAD,EAAUR,KAAV,CAAX,IAA+Be,aAA/B,EAA8C;AAC5CP,QAAAA,OAAO,CAACR,KAAR,CAAcsB,aAAd,CAA4Bd,OAAO,CAACe,UAAR,CAAmBlB,IAA/C,EAAqDL,KAArD;AACD;AACF;AACF,GA9ED;;AAgFArB,EAAAA,aAAa,CAACD,IAAd,CAAmB,IAAnB;AACAM,EAAAA,IAAI,CAACE,QAAL,GAAgBD,gBAAhB;AACD,CArFD;;AAuFA,SAASoC,aAAT,CAAuBrB,KAAvB,EAA8B;AAC5B,MAAIwB,KAAK,GAAG,CAAZ;AACA,MAAIC,GAAG,GAAGzB,KAAV;AACA,SAAQyB,GAAG,GAAGA,GAAG,CAACf,MAAlB,EAA2Bc,KAAK;AAChC,SAAOA,KAAP;AACD","sourcesContent":["import \"../types/patch\";\n\nimport * as t from \"@babel/types\";\nimport traverse, { NodePath, Scope } from \"@babel/traverse\";\nimport { MARKO_TYPES, MARKO_ALIAS_TYPES } from \"../types/definitions\";\n\nMARKO_TYPES.forEach(typeName => {\n  const checkKey = `is${typeName}`;\n  const assertKey = `assert${typeName}`;\n  const checkFn = t[checkKey];\n  const assertFn = t[assertKey];\n  NodePath.prototype[checkKey] = function (opts) {\n    return checkFn(this.node, opts);\n  };\n  NodePath.prototype[assertKey] = function (opts) {\n    assertFn(this.node, opts);\n  };\n});\n\nMARKO_ALIAS_TYPES.forEach(aliasName => {\n  const checkKey = `is${aliasName}`;\n  const originalProtoCheck = NodePath.prototype[checkKey];\n  NodePath.prototype[checkKey] = function (opts) {\n    return (\n      t.is(aliasName, this.node, opts) ||\n      originalProtoCheck.call(this, this.node, opts)\n    );\n  };\n});\n\n// Adds a one time patch to the scope collector visitors to include\n// Marko bindings for params and tag vars.\nconst originalCrawl = Scope.prototype.crawl;\nconst patchedVisitors = new WeakSet();\n\nScope.prototype.crawl = function () {\n  const path = this.path;\n  const originalTraverse = path.traverse;\n  path.traverse = function (visitor, state) {\n    state.hoistableTagVarsByScope = new Map();\n    path.traverse = originalTraverse;\n\n    if (!patchedVisitors.has(visitor)) {\n      patchedVisitors.add(visitor);\n      Object.assign(\n        traverse.explode(visitor),\n        traverse.explode({\n          MarkoTagBody(body) {\n            for (const param of body.get(\"params\")) {\n              body.scope.registerBinding(\"param\", param);\n            }\n          },\n          MarkoTag(tag, state) {\n            const tagVar = tag.get(\"var\");\n            if (tagVar.node) {\n              tag.scope.registerBinding(\"local\", tagVar, tag);\n              for (const name in tagVar.getBindingIdentifiers()) {\n                let curScope = tag.scope;\n                const binding = curScope.getBinding(name);\n\n                while ((curScope = curScope.parent)) {\n                  const hoistableTagVars =\n                    state.hoistableTagVarsByScope.get(curScope);\n\n                  if (hoistableTagVars) {\n                    hoistableTagVars[name] = hoistableTagVars[name]\n                      ? true\n                      : binding;\n                  } else {\n                    state.hoistableTagVarsByScope.set(curScope, {\n                      [name]: binding\n                    });\n                  }\n                }\n              }\n            }\n          }\n        })\n      );\n    }\n\n    this.traverse(visitor, state);\n\n    if (state.references.length) {\n      const movedBindings = new Map();\n      for (const ref of state.references) {\n        const { name } = ref.node;\n        let curScope = ref.scope;\n        if (curScope.hasBinding(name)) continue;\n\n        do {\n          const hoistableBinding =\n            state.hoistableTagVarsByScope.get(curScope)?.[name];\n\n          if (hoistableBinding) {\n            if (hoistableBinding === true) {\n              throw ref.buildCodeFrameError(\n                \"Ambiguous reference, variable was defined in multiple places and was not shadowed.\"\n              );\n            }\n\n            const movedBinding = movedBindings.get(hoistableBinding);\n            if (\n              !movedBinding ||\n              getScopeDepth(movedBinding) < getScopeDepth(curScope)\n            ) {\n              movedBindings.set(hoistableBinding, curScope);\n            }\n          }\n        } while ((curScope = curScope.parent));\n      }\n\n      for (const [binding, scope] of movedBindings) {\n        binding.scope.moveBindingTo(binding.identifier.name, scope);\n      }\n    }\n  };\n\n  originalCrawl.call(this);\n  path.traverse = originalTraverse;\n};\n\nfunction getScopeDepth(scope) {\n  let depth = 0;\n  let cur = scope;\n  while ((cur = cur.parent)) depth++;\n  return depth;\n}\n"],"file":"patch.js"}

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/babel-types/types/definitions.js"],"names":["valueFieldCommon","value","validate","MarkoDefinitions","MarkoDocumentType","aliases","builder","fields","MarkoDeclaration","MarkoCDATA","MarkoComment","MarkoText","MarkoPlaceholder","visitor","escape","default","MarkoScriptlet","body","static","MarkoClass","MarkoAttribute","name","modifier","optional","arguments","bound","MarkoSpreadAttribute","MarkoTagBody","params","functionCommon","MarkoTag","attributes","rawValue","var","MARKO_TYPES","Object","keys","MARKO_ALIAS_TYPES","Array","from","Set","reduce","all","t","concat"],"mappings":"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","sourcesContent":["import {\n  assertNodeType,\n  assertValueType,\n  arrayOfType,\n  chain,\n  assertEach\n} from \"@babel/types/lib/definitions/utils\";\n\nimport { functionCommon } from \"@babel/types/lib/definitions/core\";\nconst valueFieldCommon = {\n  value: {\n    validate: assertValueType(\"string\")\n  }\n};\n\nconst MarkoDefinitions = {\n  MarkoDocumentType: {\n    aliases: [\"Marko\", \"Statement\"],\n    builder: [\"value\"],\n    fields: { ...valueFieldCommon }\n  },\n\n  MarkoDeclaration: {\n    aliases: [\"Marko\", \"Statement\"],\n    builder: [\"value\"],\n    fields: { ...valueFieldCommon }\n  },\n\n  MarkoCDATA: {\n    aliases: [\"Marko\", \"Statement\"],\n    builder: [\"value\"],\n    fields: { ...valueFieldCommon }\n  },\n\n  MarkoComment: {\n    aliases: [\"Marko\", \"Statement\"],\n    builder: [\"value\"],\n    fields: { ...valueFieldCommon }\n  },\n\n  MarkoText: {\n    aliases: [\"Marko\", \"Statement\"],\n    builder: [\"value\"],\n    fields: { ...valueFieldCommon }\n  },\n\n  MarkoPlaceholder: {\n    aliases: [\"Marko\", \"Statement\"],\n    builder: [\"value\", \"escape\"],\n    visitor: [\"value\"],\n    fields: {\n      value: {\n        validate: assertNodeType(\"Expression\")\n      },\n      escape: {\n        validate: assertValueType(\"boolean\"),\n        default: true\n      }\n    }\n  },\n\n  MarkoScriptlet: {\n    aliases: [\"Marko\", \"Statement\"],\n    builder: [\"body\", \"static\"],\n    visitor: [\"body\"],\n    fields: {\n      body: {\n        validate: arrayOfType([\"Statement\"])\n      },\n      static: {\n        validate: assertValueType(\"boolean\"),\n        default: false\n      }\n    }\n  },\n\n  MarkoClass: {\n    aliases: [\"Marko\", \"Statement\"],\n    builder: [\"body\"],\n    visitor: [\"body\"],\n    fields: {\n      body: {\n        validate: assertNodeType(\"ClassBody\")\n      }\n    }\n  },\n\n  MarkoAttribute: {\n    aliases: [\"Marko\"],\n    builder: [\"name\", \"value\", \"modifier\", \"arguments\", \"default\", \"bound\"],\n    visitor: [\"value\", \"arguments\"],\n    fields: {\n      name: {\n        validate: assertValueType(\"string\")\n      },\n      value: {\n        validate: assertNodeType(\"Expression\")\n      },\n      modifier: {\n        validate: assertValueType(\"string\"),\n        optional: true\n      },\n      arguments: {\n        validate: chain(\n          assertValueType(\"array\"),\n          assertEach(assertNodeType(\"Expression\", \"SpreadElement\"))\n        ),\n        optional: true\n      },\n      default: {\n        validate: assertValueType(\"boolean\"),\n        optional: true\n      },\n      bound: {\n        validate: assertValueType(\"boolean\"),\n        optional: true\n      }\n    }\n  },\n\n  MarkoSpreadAttribute: {\n    aliases: [\"Marko\"],\n    builder: [\"value\"],\n    visitor: [\"value\"],\n    fields: {\n      value: {\n        validate: assertNodeType(\"Expression\")\n      }\n    }\n  },\n\n  MarkoTagBody: {\n    aliases: [\"Marko\", \"BlockParent\", \"Scope\"],\n    builder: [\"body\", \"params\"],\n    visitor: [\"params\", \"body\"],\n    fields: {\n      params: {\n        ...functionCommon.params,\n        default: []\n      },\n      body: {\n        validate: arrayOfType([\n          \"MarkoTag\",\n          \"MarkoCDATA\",\n          \"MarkoText\",\n          \"MarkoPlaceholder\",\n          \"MarkoScriptlet\",\n          \"MarkoComment\"\n        ]),\n        default: []\n      }\n    }\n  },\n\n  MarkoTag: {\n    aliases: [\"Marko\", \"Statement\"],\n    builder: [\"name\", \"attributes\", \"body\", \"arguments\", \"var\"],\n    visitor: [\"name\", \"attributes\", \"body\", \"arguments\", \"var\"],\n    fields: {\n      name: {\n        validate: assertNodeType(\"Expression\")\n      },\n      attributes: {\n        validate: arrayOfType([\"MarkoAttribute\", \"MarkoSpreadAttribute\"]),\n        default: []\n      },\n      body: {\n        validate: assertNodeType(\"MarkoTagBody\")\n      },\n      arguments: {\n        validate: chain(\n          assertValueType(\"array\"),\n          assertEach(assertNodeType(\"Expression\", \"SpreadElement\"))\n        ),\n        optional: true\n      },\n      rawValue: {\n        validate: assertValueType(\"string\"),\n        optional: true\n      },\n      var: {\n        validate: assertNodeType(\"LVal\"),\n        optional: true\n      }\n    }\n  }\n};\n\nexport default MarkoDefinitions;\nexport const MARKO_TYPES = Object.keys(MarkoDefinitions);\nexport const MARKO_ALIAS_TYPES = Array.from(\n  new Set(\n    MARKO_TYPES.reduce((all, t) => all.concat(MarkoDefinitions[t].aliases), [])\n  )\n);\n"],"file":"definitions.js"}

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/babel-types/types/patch.js"],"names":["TYPES","VISITOR_KEYS","FLIPPED_ALIAS_KEYS","DEPRECATED_KEYS","is","getBindingIdentifiers","babelTypes","keys","MARKO_TYPES","forEach","typeName","definitions","type","Object","includes","push","lowerName","toLowerCase","slice","checkKey","assertKey","node","opts","assert","builder","apply","arguments","MARKO_ALIAS_TYPES","aliasName","originalCheck","generatedValidators","originalIsReferenced","referencedValidators","default","parent","grandparent","var","Error","JSON","stringify"],"mappings":"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","sourcesContent":["/* eslint-disable no-import-assign */\nimport * as babelTypes from \"@babel/types\";\nimport builder from \"@babel/types/lib/builders/builder\";\nimport defineType from \"@babel/types/lib/definitions/utils\";\nimport * as generatedValidators from \"@babel/types/lib/validators/generated\";\nimport * as referencedValidators from \"@babel/types/lib/validators/isReferenced\";\nimport definitions, { MARKO_TYPES, MARKO_ALIAS_TYPES } from \"./definitions\";\n\nconst {\n  TYPES,\n  VISITOR_KEYS,\n  FLIPPED_ALIAS_KEYS,\n  DEPRECATED_KEYS,\n  is,\n  getBindingIdentifiers\n} = babelTypes;\n\ngetBindingIdentifiers.keys[\"MarkoTag\"] = [\"var\"];\ngetBindingIdentifiers.keys[\"MarkoTagBody\"] = [\"params\"];\n\nMARKO_TYPES.forEach(typeName => {\n  defineType(typeName, definitions[typeName]);\n});\n\nfor (const type of [\n  ...Object.keys(VISITOR_KEYS),\n  ...Object.keys(FLIPPED_ALIAS_KEYS),\n  ...Object.keys(DEPRECATED_KEYS)\n]) {\n  if (!TYPES.includes(type)) TYPES.push(type);\n}\n\nMARKO_TYPES.forEach(typeName => {\n  const lowerName = typeName[0].toLowerCase() + typeName.slice(1);\n  const checkKey = `is${typeName}`;\n  const assertKey = `assert${typeName}`;\n  babelTypes[checkKey] = (node, opts) => is(typeName, node, opts);\n  babelTypes[assertKey] = (node, opts) => assert(typeName, node, opts);\n  babelTypes[typeName] = babelTypes[lowerName] = function () {\n    return builder.apply(typeName, arguments);\n  };\n});\n\nMARKO_ALIAS_TYPES.forEach(aliasName => {\n  const checkKey = `is${aliasName}`;\n  const originalCheck = generatedValidators[checkKey];\n  generatedValidators[checkKey] = (node, opts) =>\n    is(aliasName, node, opts) || originalCheck(node, opts);\n});\n\nconst originalIsReferenced = referencedValidators.default;\nreferencedValidators.default = (node, parent, grandparent) => {\n  switch (parent.type) {\n    case \"MarkoTag\":\n      return parent.var !== node;\n    case \"MarkoTagBody\":\n      return false;\n    default:\n      return originalIsReferenced(node, parent, grandparent);\n  }\n};\n\nfunction assert(typeName, node, opts) {\n  if (!is(typeName, node, opts)) {\n    throw new Error(\n      `Expected type \"${typeName}\" with option ${JSON.stringify(\n        opts\n      )}, but instead got \"${node.type}\".`\n    );\n  }\n}\n"],"file":"patch.js"}

package/dist/config.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/config.js"],"names":["config","globalThis","window","global","MARKO_CONFIG_KEY","Symbol","output","runtimeId","ast","code","writeVersionComment","ignoreUnrecognizedTags","sourceMaps","meta","translator","translatorReg","pkg","process","cwd","name","dependencies","test","peerDependencies","devDependencies","fileSystem","fs","modules","optimize","undefined","resolveVirtualDependency","cache","Map","hydrateIncludeImports","hot","env","MARKO_CONFIG","Object","assign","JSON","parse"],"mappings":"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","sourcesContent":["import fs from \"fs\";\nimport { getRootPackage } from \"lasso-package-root\";\n\nlet config;\nconst globalThis = typeof window === \"undefined\" ? global : window;\nconst MARKO_CONFIG_KEY = Symbol(\"Default Marko Compiler Config\");\n\nif (globalThis[MARKO_CONFIG_KEY]) {\n  config = globalThis[MARKO_CONFIG_KEY];\n} else {\n  config = globalThis[MARKO_CONFIG_KEY] = {\n    // The default output mode for compiled templates\n    output: \"html\",\n\n    // Override the runtimeid used when calling `marko/components.init` in the `hydrate` output.\n    runtimeId: null,\n\n    // Have Marko provide the final AST in the compile result.\n    ast: false,\n\n    // Set the false to have Marko not generate the final code string, useful if just reading metadata or AST.\n    code: true,\n\n    /**\n     * Whether the version should be written to the template as a comment e.g.\n     * // Compiled using marko@x.x.x - DO NOT EDIT\n     */\n    writeVersionComment: true,\n\n    /**\n     * Whether unrecognized tags should be ignored or not. This flag will\n     * be enabled by default when compiling XML.\n     */\n    ignoreUnrecognizedTags: false,\n\n    /**\n     * Whether source maps should be output with the compiled templates.\n     * When `true` a `map` property will be available on the compile result.\n     * When `\"inline\"` the sourcemap will be inlined as a comment in the output code.\n     * When `\"both\"` both of the above will be used.\n     */\n    sourceMaps: false,\n\n    /**\n     * This option inlines all of the meta data in the template.\n     * You can also access this metadata via `compile(...).meta`.\n     * This API is sticking around for compatibility purposes.\n     */\n    meta: false,\n\n    /**\n     * Allows configuring Marko to compile to different runtimes.\n     */\n    translator: (() => {\n      const translatorReg = /^(@marko\\/|marko-)translator-/;\n      let translator;\n      let pkg;\n\n      try {\n        pkg = getRootPackage(process.cwd());\n        // eslint-disable-next-line no-empty\n      } catch {}\n\n      if (pkg) {\n        for (const name in pkg.dependencies) {\n          if (translatorReg.test(name)) {\n            if (translator && translator !== name) {\n              return;\n            }\n\n            translator = name;\n          }\n        }\n\n        for (const name in pkg.peerDependencies) {\n          if (translatorReg.test(name)) {\n            if (translator && translator !== name) {\n              return;\n            }\n\n            translator = name;\n          }\n        }\n\n        for (const name in pkg.devDependencies) {\n          if (translatorReg.test(name)) {\n            if (translator && translator !== name) {\n              return;\n            }\n\n            translator = name;\n          }\n        }\n      }\n\n      return translator || \"@marko/translator-default\";\n    })(),\n\n    /**\n     * Use a different file system object, eg webpacks CachedInputFileSystem or lasso-caching-fs\n     */\n    fileSystem: fs,\n    /**\n     * By default Marko 5 outputs esm, you can optionally specify commonjs.\n     *\n     * Valid options: esm | cjs\n     */\n    modules: \"esm\",\n\n    /**\n     * Enables production mode optimizations if true, or not if false.\n     * If left as undefined checks for env === \"production\".\n     */\n    optimize: undefined,\n\n    /**\n     * This option should be set if `hydrate` output is specified.\n     * Maps a virtual dependency to a resolved file which can be implemented\n     * for specific bundlers.\n     */\n    resolveVirtualDependency: null,\n\n    /**\n     * Compiling a Marko template may require other (used) Marko templates to compile.\n     * To prevent compiling templates more than once, most of the compilation is cached.\n     *\n     * The default cache strategy is to clear the cache on every macrotask.\n     * If the default cache is overwritten it is up to the user to determine when the\n     * cache is cleared.\n     */\n    cache: new Map(),\n\n    /**\n     * A regexp or function that receives an import path that matches file types known to be client side assets.\n     */\n    hydrateIncludeImports:\n      /\\.(css|less|s[ac]ss|styl|png|jpe?g|gif|svg|ico|webp|avif|mp4|webm|ogg|mp3|wav|flac|aac|woff2?|eot|ttf|otf)$/,\n\n    /**\n     * Set to true in order to bring in the hot module replacement runtime.\n     */\n    hot: false\n  };\n\n  if (process.env.MARKO_CONFIG) {\n    Object.assign(config, JSON.parse(process.env.MARKO_CONFIG));\n  }\n}\n\nexport default config;\n\nimport { setFS } from \"./taglib/fs\";\nsetFS(config.fileSystem);\n"],"file":"config.js"}

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/index.js"],"names":["globalConfig","defaultConfig","configure","newConfig","compile","src","filename","config","babelConfig","loadBabelConfig","babelResult","babel","transformAsync","scheduleDefaultClear","buildResult","compileSync","transformSync","compileFile","Promise","resolve","reject","getFs","readFile","err","compileFileSync","readFileSync","getRuntimeEntryFiles","output","requestedTranslator","translator","markoConfig","undefined","requiredPlugins","corePlugin","baseBabelConfig","filenameRelative","path","relative","process","cwd","sourceFileName","basename","sourceType","sourceMaps","code","ast","modules","push","require","loose","plugins","concat","loadPartialConfig","options","map","metadata","marko","meta","clearingDefaultCache","isDefaultCache","setImmediate","_clearDefaults","cache","clear","fileSystem"],"mappings":";AACA;AACA;AACA;AACA;AACA,0D;AACA;AACA,uF;;;AAGA,IAAIA,YAAY,GAAG,EAAE,GAAGC,eAAL,EAAnB;AACO,SAASC,SAAT,CAAmBC,SAAnB,EAA8B;AACnCH,EAAAA,YAAY,GAAG,EAAE,GAAGC,eAAL,EAAoB,GAAGE,SAAvB,EAAf;AACD;;AAEM,eAAeC,OAAf,CAAuBC,GAAvB,EAA4BC,QAA5B,EAAsCC,MAAtC,EAA8C;AACnD,QAAMC,WAAW,GAAGC,eAAe,CAACH,QAAD,EAAWC,MAAX,CAAnC;AACA,QAAMG,WAAW,GAAG,MAAMC,KAAK,CAACC,cAAN,CAAqBP,GAArB,EAA0BG,WAA1B,CAA1B;AACAK,EAAAA,oBAAoB,CAACN,MAAD,CAApB;AACA,SAAOO,WAAW,CAACJ,WAAD,CAAlB;AACD;;AAEM,SAASK,WAAT,CAAqBV,GAArB,EAA0BC,QAA1B,EAAoCC,MAApC,EAA4C;AACjD,QAAMC,WAAW,GAAGC,eAAe,CAACH,QAAD,EAAWC,MAAX,CAAnC;AACA,QAAMG,WAAW,GAAGC,KAAK,CAACK,aAAN,CAAoBX,GAApB,EAAyBG,WAAzB,CAApB;AACAK,EAAAA,oBAAoB,CAACN,MAAD,CAApB;AACA,SAAOO,WAAW,CAACJ,WAAD,CAAlB;AACD;;AAEM,eAAeO,WAAf,CAA2BX,QAA3B,EAAqCC,MAArC,EAA6C;AAClD,SAAO,IAAIW,OAAJ,CAAY,CAACC,OAAD,EAAUC,MAAV,KAAqB;AACtCC,IAAAA,KAAK,CAACd,MAAD,CAAL,CAAce,QAAd,CAAuBhB,QAAvB,EAAiC,OAAjC,EAA0C,CAACiB,GAAD,EAAMlB,GAAN,KAAc;AACtD,UAAIkB,GAAJ,EAAS;AACP,eAAOH,MAAM,CAACG,GAAD,CAAb;AACD;;AAED,aAAOJ,OAAO,CAACf,OAAO,CAACC,GAAD,EAAMC,QAAN,EAAgBC,MAAhB,CAAR,CAAd;AACD,KAND;AAOD,GARM,CAAP;AASD;;AAEM,SAASiB,eAAT,CAAyBlB,QAAzB,EAAmCC,MAAnC,EAA2C;AAChD,QAAMF,GAAG,GAAGgB,KAAK,CAACd,MAAD,CAAL,CAAckB,YAAd,CAA2BnB,QAA3B,EAAqC,OAArC,CAAZ;AACA,SAAOS,WAAW,CAACV,GAAD,EAAMC,QAAN,EAAgBC,MAAhB,CAAlB;AACD;;AAEM,SAASmB,oBAAT,CAA8BC,MAA9B,EAAsCC,mBAAtC,EAA2D;AAChE,QAAMC,UAAU,GAAG,gCAAkBD,mBAAlB,CAAnB;AACA,MAAIC,UAAU,IAAIA,UAAU,CAACH,oBAA7B,EAAmD;AACjD,WAAOG,UAAU,CAACH,oBAAX,CAAgCC,MAAhC,EAAwC,8BAAxC,CAAP;AACD;;AAED,SAAO,EAAP;AACD;;AAED,SAASlB,eAAT,CAAyBH,QAAzB,EAAmCC,MAAnC,EAA2C;AACzC,QAAMuB,WAAW,GAAG,EAAE,GAAG9B,YAAL,EAAmB,GAAGO,MAAtB,EAA8BC,WAAW,EAAEuB,SAA3C,EAApB;AACA,QAAMC,eAAe,GAAG,CAAC,CAACC,oBAAD,EAAaH,WAAb,CAAD,CAAxB;AACA,QAAMI,eAAe,GAAG;AACtBC,IAAAA,gBAAgB,EAAE7B,QAAQ;AACtB8B,kBAAKC,QAAL,CAAcC,OAAO,CAACC,GAAR,EAAd,EAA6BjC,QAA7B,CADsB;AAEtByB,IAAAA,SAHkB;AAItBS,IAAAA,cAAc,EAAElC,QAAQ,GAAG8B,cAAKK,QAAL,CAAcnC,QAAd,CAAH,GAA6ByB,SAJ/B;AAKtB,QAAIxB,MAAM,IAAIA,MAAM,CAACC,WAArB,CALsB;AAMtBF,IAAAA,QANsB;AAOtBoC,IAAAA,UAAU,EAAE,QAPU;AAQtBC,IAAAA,UAAU,EAAEb,WAAW,CAACa,UARF;AAStBC,IAAAA,IAAI,EAAEd,WAAW,CAACc,IATI;AAUtBC,IAAAA,GAAG,EAAEf,WAAW,CAACe,GAVK,EAAxB;;;AAaA,MAAIf,WAAW,CAACgB,OAAZ,KAAwB,KAA5B,EAAmC;AACjCd,IAAAA,eAAe,CAACe,IAAhB,CAAqB;AACnBC,IAAAA,OAAO,CAAC7B,OAAR,CAAgB,0CAAhB,CADmB;AAEnB,MAAE8B,KAAK,EAAE,IAAT,EAFmB,CAArB;;AAID;;AAEDf,EAAAA,eAAe,CAACgB,OAAhB,GAA0BlB,eAAe,CAACmB,MAAhB;AACxBjB,EAAAA,eAAe,CAACgB,OAAhB,IAA2B,EADH,CAA1B;;;AAIA,SAAOvC,KAAK,CAACyC,iBAAN,CAAwBlB,eAAxB,EAAyCmB,OAAhD;AACD;;AAED,SAASvC,WAAT,CAAqBJ,WAArB,EAAkC;AAChC,QAAM;AACJmC,IAAAA,GADI;AAEJS,IAAAA,GAFI;AAGJV,IAAAA,IAHI;AAIJW,IAAAA,QAAQ,EAAE,EAAEC,KAAK,EAAEC,IAAT,EAJN;AAKF/C,EAAAA,WALJ;AAMA,SAAO,EAAEmC,GAAF,EAAOS,GAAP,EAAYV,IAAZ,EAAkBa,IAAlB,EAAP;AACD;;AAED,IAAIC,oBAAoB,GAAG,KAA3B;AACA,SAAS7C,oBAAT,CAA8BN,MAA9B,EAAsC;AACpC;AACE,GAACmD,oBAAD;AACCA,EAAAA,oBAAoB,GAAGC,cAAc,CAACpD,MAAD,CADtC,CADF;AAGE;AACAqD,IAAAA,YAAY,CAACC,cAAD,CAAZ;AACD;AACF;;AAEM,SAASA,cAAT,GAA0B;AAC/BH,EAAAA,oBAAoB,GAAG,KAAvB;AACA1D,EAAAA,YAAY,CAAC8D,KAAb,CAAmBC,KAAnB;AACD;;AAED,SAASJ,cAAT,CAAwBpD,MAAxB,EAAgC;AAC9B,SAAO,CAACA,MAAM,CAACuD,KAAR,IAAiBvD,MAAM,CAACuD,KAAP,KAAiB9D,YAAY,CAAC8D,KAAtD;AACD;;AAED,SAASzC,KAAT,CAAed,MAAf,EAAuB;AACrB,SAAOA,MAAM,CAACyD,UAAP,IAAqBhE,YAAY,CAACgE,UAAzC;AACD","sourcesContent":["export * as types from \"./babel-types\";\nimport path from \"path\";\nimport * as babel from \"@babel/core\";\nimport corePlugin from \"./babel-plugin\";\nimport defaultConfig from \"./config\";\nimport * as taglib from \"./taglib\";\nimport shouldOptimize from \"./util/should-optimize\";\nimport tryLoadTranslator from \"./util/try-load-translator\";\nexport { taglib };\n\nlet globalConfig = { ...defaultConfig };\nexport function configure(newConfig) {\n  globalConfig = { ...defaultConfig, ...newConfig };\n}\n\nexport async function compile(src, filename, config) {\n  const babelConfig = loadBabelConfig(filename, config);\n  const babelResult = await babel.transformAsync(src, babelConfig);\n  scheduleDefaultClear(config);\n  return buildResult(babelResult);\n}\n\nexport function compileSync(src, filename, config) {\n  const babelConfig = loadBabelConfig(filename, config);\n  const babelResult = babel.transformSync(src, babelConfig);\n  scheduleDefaultClear(config);\n  return buildResult(babelResult);\n}\n\nexport async function compileFile(filename, config) {\n  return new Promise((resolve, reject) => {\n    getFs(config).readFile(filename, \"utf-8\", (err, src) => {\n      if (err) {\n        return reject(err);\n      }\n\n      return resolve(compile(src, filename, config));\n    });\n  });\n}\n\nexport function compileFileSync(filename, config) {\n  const src = getFs(config).readFileSync(filename, \"utf-8\");\n  return compileSync(src, filename, config);\n}\n\nexport function getRuntimeEntryFiles(output, requestedTranslator) {\n  const translator = tryLoadTranslator(requestedTranslator);\n  if (translator && translator.getRuntimeEntryFiles) {\n    return translator.getRuntimeEntryFiles(output, shouldOptimize());\n  }\n\n  return [];\n}\n\nfunction loadBabelConfig(filename, config) {\n  const markoConfig = { ...globalConfig, ...config, babelConfig: undefined };\n  const requiredPlugins = [[corePlugin, markoConfig]];\n  const baseBabelConfig = {\n    filenameRelative: filename\n      ? path.relative(process.cwd(), filename)\n      : undefined,\n    sourceFileName: filename ? path.basename(filename) : undefined,\n    ...(config && config.babelConfig),\n    filename,\n    sourceType: \"module\",\n    sourceMaps: markoConfig.sourceMaps,\n    code: markoConfig.code,\n    ast: markoConfig.ast\n  };\n\n  if (markoConfig.modules === \"cjs\") {\n    requiredPlugins.push([\n      require.resolve(\"@babel/plugin-transform-modules-commonjs\"),\n      { loose: true }\n    ]);\n  }\n\n  baseBabelConfig.plugins = requiredPlugins.concat(\n    baseBabelConfig.plugins || []\n  );\n\n  return babel.loadPartialConfig(baseBabelConfig).options;\n}\n\nfunction buildResult(babelResult) {\n  const {\n    ast,\n    map,\n    code,\n    metadata: { marko: meta }\n  } = babelResult;\n  return { ast, map, code, meta };\n}\n\nlet clearingDefaultCache = false;\nfunction scheduleDefaultClear(config) {\n  if (\n    !clearingDefaultCache &&\n    (clearingDefaultCache = isDefaultCache(config))\n  ) {\n    setImmediate(_clearDefaults);\n  }\n}\n\nexport function _clearDefaults() {\n  clearingDefaultCache = false;\n  globalConfig.cache.clear();\n}\n\nfunction isDefaultCache(config) {\n  return !config.cache || config.cache === globalConfig.cache;\n}\n\nfunction getFs(config) {\n  return config.fileSystem || globalConfig.fileSystem;\n}\n"],"file":"index.js"}

package/dist/register.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/register.js"],"names":["compiler","require","requiredOptions","modules","module","exports","register","extensions","options","filename","_compile","compileFileSync","Object","assign","sourceMaps","code"],"mappings":"AAAA;;AAEA,MAAMA,QAAQ,GAAGC,OAAO,CAAC,GAAD,CAAxB;AACA,MAAMC,eAAe,GAAG,EAAEC,OAAO,EAAE,KAAX,EAAxB;;AAEAC,MAAM,CAACC,OAAP,GAAiBC,QAAjB;AACAA,QAAQ;;AAER,SAASA,QAAT,CAAkB,EAAEC,UAAU,GAAGN,OAAO,CAACM,UAAvB,EAAmC,GAAGC,OAAtC,KAAkD,EAApE,EAAwE;AACtED,EAAAA,UAAU,CAAC,QAAD,CAAV,GAAuB,CAACH,MAAD,EAASK,QAAT;AACrBL,EAAAA,MAAM,CAACM,QAAP;AACEV,EAAAA,QAAQ,CAACW,eAAT;AACEF,EAAAA,QADF;AAEEG,EAAAA,MAAM,CAACC,MAAP;AACE;AACA,IAAEC,UAAU,EAAE,gBAAgB,QAAhB,GAA2B,KAAzC,EAFF;AAGEN,EAAAA,OAHF;AAIEN,EAAAA,eAJF,CAFF;;AAQEa,EAAAA,IATJ;AAUEN,EAAAA,QAVF,CADF;;AAaA,SAAOF,UAAP;AACD","sourcesContent":["\"use strict\";\n\nconst compiler = require(\".\");\nconst requiredOptions = { modules: \"cjs\" };\n\nmodule.exports = register;\nregister();\n\nfunction register({ extensions = require.extensions, ...options } = {}) {\n  extensions[\".marko\"] = (module, filename) =>\n    module._compile(\n      compiler.compileFileSync(\n        filename,\n        Object.assign(\n          // eslint-disable-next-line no-constant-condition\n          { sourceMaps: \"MARKO_DEBUG\" ? \"inline\" : false },\n          options,\n          requiredOptions\n        )\n      ).code,\n      filename\n    );\n  return extensions;\n}\n"],"file":"register.js"}

package/dist/taglib/finder/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/taglib/finder/index.js"],"names":["nodePath","require","resolveFrom","silent","taglibFS","taglibLoader","lassoPackageRoot","scanTagsDir","DependencyChain","hasOwnProperty","Object","prototype","findCache","excludedDirs","excludedPackages","reset","clearCache","getModuleRootPackage","dirname","getRootPackage","e","undefined","getAllDependencyNames","pkg","map","dependencies","keys","forEach","name","peerDependencies","devDependencies","find","registeredTaglibs","found","added","helper","alreadyAdded","taglibId","call","addTaglib","taglib","id","push","foundTaglibPackages","rootDirname","process","cwd","rootPkg","__dirname","curDirname","taglibPath","join","existsSync","loadTaglibFromFile","tagsDir","componentsPath","createTaglib","parentDirname","concat","excludeDir","dir","excludePackage","file","curFS","statSync","_","exports"],"mappings":"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","sourcesContent":["\"use strict\";\nvar nodePath = require(\"path\");\nvar resolveFrom = require(\"resolve-from\").silent;\nvar taglibFS = require(\"../fs\");\nvar taglibLoader = require(\"../loader\");\nvar lassoPackageRoot = require(\"lasso-package-root\");\nvar scanTagsDir = require(\"../loader/scanTagsDir\");\nvar DependencyChain = require(\"../loader/DependencyChain\");\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nvar findCache = {};\nvar excludedDirs = {};\nvar excludedPackages = {};\n\n/**\n * Reset all internal state to the default state. This\n * was added for testing purposes.\n */\nfunction reset() {\n  clearCache();\n  excludedDirs = {};\n  excludedPackages = {};\n}\n\nfunction getModuleRootPackage(dirname) {\n  try {\n    return lassoPackageRoot.getRootPackage(dirname);\n  } catch (e) {\n    return undefined;\n  }\n}\n\nfunction getAllDependencyNames(pkg) {\n  var map = {};\n\n  if (pkg.dependencies) {\n    Object.keys(pkg.dependencies).forEach(name => {\n      map[name] = true;\n    });\n  }\n\n  if (pkg.peerDependencies) {\n    Object.keys(pkg.peerDependencies).forEach(name => {\n      map[name] = true;\n    });\n  }\n\n  if (pkg.devDependencies) {\n    Object.keys(pkg.devDependencies).forEach(name => {\n      map[name] = true;\n    });\n  }\n\n  return Object.keys(map);\n}\n\nfunction find(dirname, registeredTaglibs) {\n  var found = findCache[dirname];\n  if (found) {\n    return found;\n  }\n\n  found = [];\n\n  var added = {};\n\n  var helper = {\n    alreadyAdded: function (taglibId) {\n      return hasOwnProperty.call(added, taglibId);\n    },\n    addTaglib: function (taglib) {\n      if (added[taglib.id]) {\n        return;\n      }\n\n      added[taglib.id] = true;\n      found.push(taglib);\n    },\n    foundTaglibPackages: {}\n  };\n\n  var rootDirname = process.cwd(); // Don't search up past this directory\n  var rootPkg = getModuleRootPackage(dirname);\n  if (rootPkg) {\n    rootDirname = rootPkg.__dirname; // Use the package's root directory as the top-level directory\n  }\n\n  // First walk up the directory tree looking for marko.json files or components/ directories\n  let curDirname = dirname;\n  // eslint-disable-next-line no-constant-condition\n  while (true) {\n    if (!excludedDirs[curDirname]) {\n      let taglibPath = nodePath.join(curDirname, \"marko.json\");\n      let taglib;\n\n      if (existsSync(taglibPath)) {\n        taglib = taglibLoader.loadTaglibFromFile(taglibPath);\n        helper.addTaglib(taglib);\n      }\n\n      if (!taglib || taglib.tagsDir === undefined) {\n        let componentsPath = nodePath.join(curDirname, \"components\");\n\n        if (\n          existsSync(componentsPath) &&\n          !excludedDirs[componentsPath] &&\n          !helper.alreadyAdded(componentsPath)\n        ) {\n          let taglib = taglibLoader.createTaglib(componentsPath);\n          scanTagsDir(\n            componentsPath,\n            nodePath.dirname(componentsPath),\n            \"components\",\n            taglib,\n            new DependencyChain([componentsPath])\n          );\n          helper.addTaglib(taglib);\n        }\n      }\n    }\n\n    if (curDirname === rootDirname) {\n      break;\n    }\n\n    let parentDirname = nodePath.dirname(curDirname);\n    if (!parentDirname || parentDirname === curDirname) {\n      break;\n    }\n    curDirname = parentDirname;\n  }\n\n  if (rootPkg) {\n    // Now look for `marko.json` from installed packages\n    getAllDependencyNames(rootPkg).forEach(name => {\n      if (!excludedPackages[name]) {\n        let taglibPath = resolveFrom(\n          rootPkg.__dirname,\n          nodePath.join(name, \"marko.json\")\n        );\n        if (taglibPath) {\n          var taglib = taglibLoader.loadTaglibFromFile(taglibPath);\n          helper.addTaglib(taglib);\n        }\n      }\n    });\n  }\n\n  found = found.concat(registeredTaglibs);\n\n  findCache[dirname] = found;\n\n  return found;\n}\n\nfunction clearCache() {\n  findCache = {};\n}\n\nfunction excludeDir(dir) {\n  excludedDirs[dir] = true;\n}\n\nfunction excludePackage(name) {\n  excludedPackages[name] = true;\n}\n\nfunction existsSync(file) {\n  try {\n    taglibFS.curFS.statSync(file);\n    return true;\n  } catch (_) {\n    return false;\n  }\n}\n\nexports.reset = reset;\nexports.find = find;\nexports.clearCache = clearCache;\nexports.excludeDir = excludeDir;\nexports.excludePackage = excludePackage;\n"],"file":"index.js"}

package/dist/taglib/fs.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/taglib/fs.js"],"names":["curFS","setFS","fs"],"mappings":"oFAAO,IAAIA,KAAJ,C;AACA,SAASC,KAAT,CAAeC,EAAf,EAAmB;AACxB,kBAAAF,KAAK,GAAGE,EAAR;AACD","sourcesContent":["export let curFS;\nexport function setFS(fs) {\n  curFS = fs;\n}\n"],"file":"fs.js"}

package/dist/taglib/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/taglib/index.js"],"names":["excludeDir","finder","excludePackage","registeredTaglibs","loadedTranslatorsTaglibs","Map","lookupCache","Object","create","register","markoHTMLTaglib","markoSVGTaglib","markoMathTaglib","buildLookup","dirname","requestedTranslator","translator","Array","isArray","taglibs","Error","has","set","map","id","props","loadTaglib","taglibsForDir","find","concat","get","cacheKey","it","join","lookup","Lookup","i","length","taglib","addTaglib","imports","importedTaglib","hasTaglib","push","clearCaches","loader","clearCache","_loader","_finder","loadTaglibFromProps","createTaglib"],"mappings":"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","sourcesContent":["import loader from \"./loader\";\nimport finder from \"./finder\";\nimport Lookup from \"./lookup\";\nimport tryLoadTranslator from \"../util/try-load-translator\";\n\nexport const excludeDir = finder.excludeDir;\nexport const excludePackage = finder.excludePackage;\n\nimport markoHTMLTaglib from \"./marko-html.json\";\nimport markoSVGTaglib from \"./marko-svg.json\";\nimport markoMathTaglib from \"./marko-math.json\";\n\nconst registeredTaglibs = [];\nconst loadedTranslatorsTaglibs = new Map();\nlet lookupCache = Object.create(null);\n\nregister(\"marko/html\", markoHTMLTaglib);\nregister(\"marko/svg\", markoSVGTaglib);\nregister(\"marko/math\", markoMathTaglib);\n\nexport function buildLookup(dirname, requestedTranslator) {\n  const translator = tryLoadTranslator(requestedTranslator);\n  if (!translator || !Array.isArray(translator.taglibs)) {\n    throw new Error(\n      \"@marko/compiler: Invalid translator provided to buildLookup(dir, translator)\"\n    );\n  }\n\n  if (!loadedTranslatorsTaglibs.has(translator)) {\n    loadedTranslatorsTaglibs.set(\n      translator,\n      translator.taglibs.map(([id, props]) => loadTaglib(id, props))\n    );\n  }\n\n  const taglibsForDir = finder.find(\n    dirname,\n    registeredTaglibs.concat(loadedTranslatorsTaglibs.get(translator))\n  );\n\n  const cacheKey = taglibsForDir.map(it => it.id).join();\n  let lookup = lookupCache[cacheKey];\n\n  if (!lookup) {\n    lookup = lookupCache[cacheKey] = new Lookup();\n    for (let i = taglibsForDir.length; i--; ) {\n      const taglib = taglibsForDir[i];\n      lookup.addTaglib(taglib);\n      if (taglib.imports) {\n        for (const importedTaglib of taglib.imports) {\n          if (!lookup.hasTaglib(importedTaglib)) {\n            lookup.addTaglib(importedTaglib);\n          }\n        }\n      }\n    }\n  }\n\n  return lookup;\n}\n\nexport function register(id, props) {\n  registeredTaglibs.push(loadTaglib(id, props));\n}\n\nexport function clearCaches() {\n  loader.clearCache();\n  finder.clearCache();\n  lookupCache = Object.create(null);\n}\n\n// Used by legacy compiler api.\nexport const _loader = loader;\nexport const _finder = finder;\n\nfunction loadTaglib(id, props) {\n  return loader.loadTaglibFromProps(loader.createTaglib(id), props);\n}\n"],"file":"index.js"}

package/dist/taglib/loader/Attribute.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/taglib/loader/Attribute.js"],"names":["Attribute","constructor","name","type","required","allowExpressions","setFlag","pattern","module","exports"],"mappings":"AAAA;;AAEA,MAAMA,SAAN,CAAgB;AACdC,EAAAA,WAAW,CAACC,IAAD,EAAO;AAChB,SAAKA,IAAL,GAAYA,IAAZ;AACA,SAAKC,IAAL,GAAY,IAAZ;AACA,SAAKC,QAAL,GAAgB,KAAhB;AACA,SAAKD,IAAL,GAAY,IAAZ;AACA,SAAKE,gBAAL,GAAwB,IAAxB;AACA,SAAKC,OAAL,GAAe,IAAf;AACA,SAAKC,OAAL,GAAe,IAAf;AACD,GATa;;;AAYhBC,MAAM,CAACC,OAAP,GAAiBT,SAAjB","sourcesContent":["\"use strict\";\n\nclass Attribute {\n  constructor(name) {\n    this.name = name;\n    this.type = null;\n    this.required = false;\n    this.type = null;\n    this.allowExpressions = true;\n    this.setFlag = null;\n    this.pattern = null;\n  }\n}\n\nmodule.exports = Attribute;\n"],"file":"Attribute.js"}

package/dist/taglib/loader/DependencyChain.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/taglib/loader/DependencyChain.js"],"names":["DependencyChain","constructor","array","append","str","concat","toString","join","module","exports"],"mappings":"AAAA;;AAEA,MAAMA,eAAN,CAAsB;AACpBC,EAAAA,WAAW,CAACC,KAAD,EAAQ;AACjB,SAAKA,KAAL,GAAaA,KAAK,IAAI,EAAtB;AACD;;AAEDC,EAAAA,MAAM,CAACC,GAAD,EAAM;AACV,WAAO,IAAIJ,eAAJ,CAAoB,KAAKE,KAAL,CAAWG,MAAX,CAAkBD,GAAlB,CAApB,CAAP;AACD;;AAEDE,EAAAA,QAAQ,GAAG;AACT,WAAO,MAAM,KAAKJ,KAAL,CAAWK,IAAX,CAAgB,KAAhB,CAAN,GAA+B,GAAtC;AACD,GAXmB;;;AActBC,MAAM,CAACC,OAAP,GAAiBT,eAAjB","sourcesContent":["\"use strict\";\n\nclass DependencyChain {\n  constructor(array) {\n    this.array = array || [];\n  }\n\n  append(str) {\n    return new DependencyChain(this.array.concat(str));\n  }\n\n  toString() {\n    return \"[\" + this.array.join(\" → \") + \"]\";\n  }\n}\n\nmodule.exports = DependencyChain;\n"],"file":"DependencyChain.js"}

package/dist/taglib/loader/Property.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/taglib/loader/Property.js"],"names":["Property","constructor","name","type","value","undefined","module","exports"],"mappings":"AAAA;;AAEA,MAAMA,QAAN,CAAe;AACbC,EAAAA,WAAW,GAAG;AACZ,SAAKC,IAAL,GAAY,IAAZ;AACA,SAAKC,IAAL,GAAY,QAAZ;AACA,SAAKC,KAAL,GAAaC,SAAb;AACD,GALY;;;AAQfC,MAAM,CAACC,OAAP,GAAiBP,QAAjB","sourcesContent":["\"use strict\";\n\nclass Property {\n  constructor() {\n    this.name = null;\n    this.type = \"string\";\n    this.value = undefined;\n  }\n}\n\nmodule.exports = Property;\n"],"file":"Property.js"}

package/dist/taglib/loader/Tag.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/taglib/loader/Tag.js"],"names":["ok","require","path","hasOwnProperty","Object","prototype","Tag","constructor","filePath","dir","dirname","migrators","attributes","transformers","patternAttributes","addAttribute","attr","pattern","push","name","dynamicAttribute","targetProperty","undefined","toString","taglibId","forEachAttribute","callback","thisObj","attrName","call","getAttribute","attribute","i","len","length","patternAttribute","test","hasAttribute","addNestedTag","nestedTag","nestedTags","isNestedTag","hasNestedTags","toJSON","setTaglib","taglib","id","taglibPath","module","exports"],"mappings":"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","sourcesContent":["\"use strict\";\nvar ok = require(\"assert\").ok;\nvar path = require(\"path\");\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nclass Tag {\n  constructor(filePath) {\n    this.filePath = filePath;\n    if (filePath) {\n      this.dir = path.dirname(filePath);\n    }\n\n    this.migrators = [];\n    this.attributes = {};\n    this.transformers = [];\n    this.patternAttributes = [];\n  }\n\n  addAttribute(attr) {\n    attr.filePath = this.filePath;\n\n    if (attr.pattern) {\n      this.patternAttributes.push(attr);\n    } else {\n      if (attr.name === \"*\") {\n        attr.dynamicAttribute = true;\n\n        if (attr.targetProperty === undefined || attr.targetProperty === \"\") {\n          attr.targetProperty = null;\n        }\n      }\n\n      this.attributes[attr.name] = attr;\n    }\n  }\n  toString() {\n    return \"[Tag: <\" + this.name + \"@\" + this.taglibId + \">]\";\n  }\n  forEachAttribute(callback, thisObj) {\n    for (var attrName in this.attributes) {\n      if (hasOwnProperty.call(this.attributes, attrName)) {\n        callback.call(thisObj, this.attributes[attrName]);\n      }\n    }\n  }\n  getAttribute(attrName) {\n    var attributes = this.attributes;\n\n    // try by exact match first\n    var attribute = attributes[attrName] || attributes[\"*\"];\n\n    if (attribute === undefined && this.patternAttributes) {\n      // try searching by pattern\n      for (var i = 0, len = this.patternAttributes.length; i < len; i++) {\n        var patternAttribute = this.patternAttributes[i];\n        if (patternAttribute.pattern.test(attrName)) {\n          attribute = patternAttribute;\n          break;\n        }\n      }\n    }\n\n    return attribute;\n  }\n\n  hasAttribute(attrName) {\n    return hasOwnProperty.call(this.attributes, attrName);\n  }\n\n  addNestedTag(nestedTag) {\n    ok(nestedTag.name, '\"nestedTag.name\" is required');\n\n    if (!this.nestedTags) {\n      this.nestedTags = {};\n    }\n\n    nestedTag.isNestedTag = true;\n\n    if (!nestedTag.targetProperty) {\n      nestedTag.targetProperty = nestedTag.name;\n    }\n\n    this.nestedTags[nestedTag.name] = nestedTag;\n  }\n\n  hasNestedTags() {\n    return this.nestedTags != null;\n  }\n\n  toJSON() {\n    return this;\n  }\n\n  setTaglib(taglib) {\n    this.taglibId = taglib ? taglib.id : null;\n    this.taglibPath = taglib ? taglib.path : null;\n  }\n}\n\nmodule.exports = Tag;\n"],"file":"Tag.js"}

package/dist/taglib/loader/Taglib.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/taglib/loader/Taglib.js"],"names":["ok","require","path","loaders","hasOwnProperty","Object","prototype","handleImport","taglib","importedTaglib","importsLookup","call","imports","push","forEach","nestedImportedTaglib","Taglib","constructor","filePath","id","dirname","tags","migrators","transformers","attributes","patternAttributes","addAttribute","attribute","key","pattern","name","Error","inspect","getAttribute","i","len","length","patternAttribute","test","addTag","tag","arguments","JSON","stringify","taglibId","addImport","loadTaglibFromFile","toJSON","module","exports"],"mappings":"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","sourcesContent":["\"use strict\";\nvar ok = require(\"assert\").ok;\nvar path = require(\"path\");\nvar loaders = require(\"./loaders\");\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nfunction handleImport(taglib, importedTaglib) {\n  var importsLookup = taglib.importsLookup || (taglib.importsLookup = {});\n  if (hasOwnProperty.call(importsLookup, importedTaglib.path)) {\n    return;\n  }\n\n  importsLookup[importedTaglib.path] = importedTaglib;\n\n  if (!taglib.imports) {\n    taglib.imports = [];\n  }\n\n  taglib.imports.push(importedTaglib);\n\n  if (importedTaglib.imports) {\n    importedTaglib.imports.forEach(function (nestedImportedTaglib) {\n      handleImport(taglib, nestedImportedTaglib);\n    });\n  }\n}\n\nclass Taglib {\n  constructor(filePath) {\n    ok(filePath, '\"filePath\" expected');\n    this.filePath = this.path /* deprecated */ = this.id = filePath;\n    this.dirname = path.dirname(this.filePath);\n    this.tags = {};\n    this.migrators = [];\n    this.transformers = [];\n    this.attributes = {};\n    this.patternAttributes = [];\n    this.imports = null;\n    this.importsLookup = null;\n  }\n\n  addAttribute(attribute) {\n    ok(attribute.key, '\"key\" is required for global attributes');\n\n    attribute.filePath = this.filePath;\n\n    if (!attribute.pattern && !attribute.name) {\n      throw new Error(\n        \"Invalid attribute: \" + require(\"util\").inspect(attribute)\n      );\n    }\n\n    this.attributes[attribute.key] = attribute;\n  }\n  getAttribute(name) {\n    var attribute = this.attributes[name];\n    if (!attribute) {\n      for (var i = 0, len = this.patternAttributes.length; i < len; i++) {\n        var patternAttribute = this.patternAttributes[i];\n        if (patternAttribute.pattern.test(name)) {\n          attribute = patternAttribute;\n        }\n      }\n    }\n    return attribute;\n  }\n  addTag(tag) {\n    ok(arguments.length === 1, \"Invalid args\");\n    if (!tag.name) {\n      throw new Error('\"tag.name\" is required: ' + JSON.stringify(tag));\n    }\n    this.tags[tag.name] = tag;\n    tag.taglibId = this.id || this.path;\n  }\n\n  addImport(path) {\n    var importedTaglib = loaders.loadTaglibFromFile(path);\n    handleImport(this, importedTaglib);\n  }\n\n  toJSON() {\n    return {\n      path: this.path,\n      tags: this.tags,\n      attributes: this.attributes,\n      patternAttributes: this.patternAttributes,\n      imports: this.imports\n    };\n  }\n}\n\nmodule.exports = Taglib;\n"],"file":"Taglib.js"}

package/dist/taglib/loader/Transformer.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/taglib/loader/Transformer.js"],"names":["nextTransformerId","Transformer","constructor","id","name","tag","path","_func","toString","module","exports"],"mappings":"AAAA;AACA,IAAIA,iBAAiB,GAAG,CAAxB;;AAEA,MAAMC,WAAN,CAAkB;AAChBC,EAAAA,WAAW,GAAG;AACZ,SAAKC,EAAL,GAAUH,iBAAiB,EAA3B;AACA,SAAKI,IAAL,GAAY,IAAZ;AACA,SAAKC,GAAL,GAAW,IAAX;AACA,SAAKC,IAAL,GAAY,IAAZ;AACA,SAAKC,KAAL,GAAa,IAAb;AACD;;AAEDC,EAAAA,QAAQ,GAAG;AACT,WAAO,0BAA0B,KAAKF,IAA/B,GAAsC,GAA7C;AACD,GAXe;;;AAclBG,MAAM,CAACC,OAAP,GAAiBT,WAAjB","sourcesContent":["\"use strict\";\nvar nextTransformerId = 0;\n\nclass Transformer {\n  constructor() {\n    this.id = nextTransformerId++;\n    this.name = null;\n    this.tag = null;\n    this.path = null;\n    this._func = null;\n  }\n\n  toString() {\n    return \"[Taglib.Transformer: \" + this.path + \"]\";\n  }\n}\n\nmodule.exports = Transformer;\n"],"file":"Transformer.js"}

package/dist/taglib/loader/cache.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/taglib/loader/cache.js"],"names":["cache","get","key","put","value","clear","exports"],"mappings":"aAAA,IAAIA,KAAK,GAAG,EAAZ;;AAEA,SAASC,GAAT,CAAaC,GAAb,EAAkB;AAChB,SAAOF,KAAK,CAACE,GAAD,CAAZ;AACD;;AAED,SAASC,GAAT,CAAaD,GAAb,EAAkBE,KAAlB,EAAyB;AACvBJ,EAAAA,KAAK,CAACE,GAAD,CAAL,GAAaE,KAAb;AACD;;AAED,SAASC,KAAT,GAAiB;AACfL,EAAAA,KAAK,GAAG,EAAR;AACD;;AAEDM,OAAO,CAACL,GAAR,GAAcA,GAAd;AACAK,OAAO,CAACH,GAAR,GAAcA,GAAd;AACAG,OAAO,CAACD,KAAR,GAAgBA,KAAhB","sourcesContent":["var cache = {};\n\nfunction get(key) {\n  return cache[key];\n}\n\nfunction put(key, value) {\n  cache[key] = value;\n}\n\nfunction clear() {\n  cache = {};\n}\n\nexports.get = get;\nexports.put = put;\nexports.clear = clear;\n"],"file":"cache.js"}

package/dist/taglib/loader/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/taglib/loader/index.js"],"names":["cache","require","types","loaders","DependencyChain","loadTaglibFromProps","taglib","taglibProps","loadTaglibFromFile","filePath","clearCache","clear","createTaglib","Taglib","loadTag","tagProps","tag","Tag","loadTagFromProps","exports"],"mappings":"aAAA,IAAIA,KAAK,GAAGC,OAAO,CAAC,SAAD,CAAnB;;AAEA,IAAIC,KAAK,GAAGD,OAAO,CAAC,SAAD,CAAnB;AACA,IAAIE,OAAO,GAAGF,OAAO,CAAC,WAAD,CAArB;AACA,IAAIG,eAAe,GAAGH,OAAO,CAAC,mBAAD,CAA7B;;AAEA,SAASI,mBAAT,CAA6BC,MAA7B,EAAqCC,WAArC,EAAkD;AAChD,SAAOJ,OAAO,CAACE,mBAAR,CAA4BC,MAA5B,EAAoCC,WAApC,CAAP;AACD;;AAED,SAASC,kBAAT,CAA4BC,QAA5B,EAAsC;AACpC,SAAON,OAAO,CAACK,kBAAR,CAA2BC,QAA3B,CAAP;AACD;;AAED,SAASC,UAAT,GAAsB;AACpBV,EAAAA,KAAK,CAACW,KAAN;AACD;;AAED,SAASC,YAAT,CAAsBH,QAAtB,EAAgC;AAC9B,SAAO,IAAIP,KAAK,CAACW,MAAV,CAAiBJ,QAAjB,CAAP;AACD;;AAED,SAASK,OAAT,CAAiBC,QAAjB,EAA2BN,QAA3B,EAAqC;AACnC,MAAIO,GAAG,GAAG,IAAId,KAAK,CAACe,GAAV,CAAcR,QAAd,CAAV;AACAN,EAAAA,OAAO,CAACe,gBAAR;AACEF,EAAAA,GADF;AAEED,EAAAA,QAFF;AAGE,MAAIX,eAAJ,CAAoBK,QAAQ,GAAG,CAACA,QAAD,CAAH,GAAgB,EAA5C,CAHF;;AAKA,SAAOO,GAAP;AACD;;AAEDG,OAAO,CAACT,UAAR,GAAqBA,UAArB;AACAS,OAAO,CAACP,YAAR,GAAuBA,YAAvB;AACAO,OAAO,CAACd,mBAAR,GAA8BA,mBAA9B;AACAc,OAAO,CAACX,kBAAR,GAA6BA,kBAA7B;AACAW,OAAO,CAACL,OAAR,GAAkBA,OAAlB","sourcesContent":["var cache = require(\"./cache\");\n\nvar types = require(\"./types\");\nvar loaders = require(\"./loaders\");\nvar DependencyChain = require(\"./DependencyChain\");\n\nfunction loadTaglibFromProps(taglib, taglibProps) {\n  return loaders.loadTaglibFromProps(taglib, taglibProps);\n}\n\nfunction loadTaglibFromFile(filePath) {\n  return loaders.loadTaglibFromFile(filePath);\n}\n\nfunction clearCache() {\n  cache.clear();\n}\n\nfunction createTaglib(filePath) {\n  return new types.Taglib(filePath);\n}\n\nfunction loadTag(tagProps, filePath) {\n  var tag = new types.Tag(filePath);\n  loaders.loadTagFromProps(\n    tag,\n    tagProps,\n    new DependencyChain(filePath ? [filePath] : [])\n  );\n  return tag;\n}\n\nexports.clearCache = clearCache;\nexports.createTaglib = createTaglib;\nexports.loadTaglibFromProps = loadTaglibFromProps;\nexports.loadTaglibFromFile = loadTaglibFromFile;\nexports.loadTag = loadTag;\n"],"file":"index.js"}

package/dist/taglib/loader/json-file-reader.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/taglib/loader/json-file-reader.js"],"names":["taglibFS","require","stripJsonComments","fsReadOptions","encoding","exports","readFileSync","path","json","String","curFS","taglibProps","JSON","parse","e","Error"],"mappings":"aAAA,IAAIA,QAAQ,GAAGC,OAAO,CAAC,OAAD,CAAtB;AACA,IAAIC,iBAAiB,GAAGD,OAAO,CAAC,qBAAD,CAA/B;AACA,IAAIE,aAAa,GAAG,EAAEC,QAAQ,EAAE,MAAZ,EAApB;;AAEAC,OAAO,CAACC,YAAR,GAAuB,UAAUC,IAAV,EAAgB;AACrC,MAAIC,IAAI,GAAGC,MAAM,CAACT,QAAQ,CAACU,KAAT,CAAeJ,YAAf,CAA4BC,IAA5B,EAAkCJ,aAAlC,CAAD,CAAjB;;AAEA,MAAI;AACF,QAAIQ,WAAW,GAAGC,IAAI,CAACC,KAAL,CAAWX,iBAAiB,CAACM,IAAD,CAA5B,CAAlB;AACA,WAAOG,WAAP;AACD,GAHD,CAGE,OAAOG,CAAP,EAAU;AACV,UAAM,IAAIC,KAAJ;AACJ,4CAAwCR,IAAxC,GAA+C,YAA/C,GAA8DO,CAD1D,CAAN;;AAGD;AACF,CAXD","sourcesContent":["var taglibFS = require(\"../fs\");\nvar stripJsonComments = require(\"strip-json-comments\");\nvar fsReadOptions = { encoding: \"utf8\" };\n\nexports.readFileSync = function (path) {\n  var json = String(taglibFS.curFS.readFileSync(path, fsReadOptions));\n\n  try {\n    var taglibProps = JSON.parse(stripJsonComments(json));\n    return taglibProps;\n  } catch (e) {\n    throw new Error(\n      'Unable to parse JSON file at path \"' + path + '\". Error: ' + e\n    );\n  }\n};\n"],"file":"json-file-reader.js"}

package/dist/taglib/loader/loadAttributeFromProps.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/taglib/loader/loadAttributeFromProps.js"],"names":["assert","require","raptorRegexp","propertyHandlers","types","createError","hasOwnProperty","Object","prototype","AttrLoader","constructor","attr","dependencyChain","ok","load","attrProps","arguments","length","type","toString","value","charAt","ref","substring","targetProperty","defaultValue","pattern","patternRegExp","simple","name","allowExpressions","preserveName","required","removeDashes","description","setFlag","setContextFlag","ignore","autocomplete","enum","deprecated","html","loadAttributeFromProps","attrName","Attribute","attrLoader","err","isSupportedProperty","call","module","exports"],"mappings":"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","sourcesContent":["\"use strict\";\n\nvar assert = require(\"assert\");\nvar raptorRegexp = require(\"raptor-regexp\");\nvar propertyHandlers = require(\"property-handlers\");\nvar types = require(\"./types\");\nvar createError = require(\"raptor-util/createError\");\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nclass AttrLoader {\n  constructor(attr, dependencyChain) {\n    assert.ok(attr, '\"attr\" is required');\n    assert.ok(dependencyChain, '\"dependencyChain\" is required');\n\n    this.attr = attr;\n    this.dependencyChain = dependencyChain;\n  }\n\n  load(attrProps) {\n    assert.ok(arguments.length === 1);\n\n    if (attrProps == null) {\n      attrProps = {};\n    } else if (typeof attrProps === \"string\") {\n      attrProps = {\n        type: attrProps\n      };\n    } else {\n      assert.ok(typeof attrProps === \"object\", 'Invalid \"attrProps\"');\n    }\n\n    propertyHandlers(attrProps, this, this.dependencyChain.toString());\n  }\n\n  /**\n   * The attribute type. One of the following:\n   * - string (the default)\n   * - expression (a JavaScript expression)\n   * - number\n   * - integer\n   * - int\n   * - boolean\n   * - float\n   * - double\n   * - object\n   * - array\n   *\n   */\n  type(value) {\n    var attr = this.attr;\n    if (value.charAt(0) === \"#\") {\n      attr.ref = value.substring(1);\n    } else {\n      attr.type = value;\n    }\n  }\n\n  /**\n   * The name of the target property to use when mapping\n   * the attribute to a property on the target object.\n   */\n  targetProperty(value) {\n    var attr = this.attr;\n    attr.targetProperty = value;\n  }\n  /**\n   * The \"default-value\" property allows a default value\n   * to be provided when the attribute is not declared\n   * on the custom tag.\n   */\n  defaultValue(value) {\n    var attr = this.attr;\n    attr.defaultValue = value;\n  }\n  /**\n   * The \"pattern\" property allows the attribute\n   * to be matched based on a simplified regular expression.\n   *\n   * Example:\n   *\n   * \"pattern\": \"myprefix-*\"\n   */\n  pattern(value) {\n    var attr = this.attr;\n    if (value === true) {\n      var patternRegExp = raptorRegexp.simple(attr.name);\n      attr.pattern = patternRegExp;\n    }\n  }\n\n  /**\n   * If \"allow-expressions\" is set to true (the default) then\n   * the the attribute value will be parsed to find any dynamic\n   * parts.\n   */\n  allowExpressions(value) {\n    var attr = this.attr;\n    attr.allowExpressions = value;\n  }\n\n  /**\n   * By default, the Marko compiler maps an attribute\n   * to a property by removing all dashes from the attribute\n   * name and converting each character after a dash to\n   * an uppercase character (e.g. \"my-attr\" --> \"myAttr\").\n   *\n   * Setting \"preserve-name\" to true will prevent this from\n   * happening for the attribute.\n   */\n  preserveName(value) {\n    var attr = this.attr;\n    attr.preserveName = value;\n  }\n  /**\n   * Declares an attribute as required. Currently, this is\n   * not enforced and is only used for documentation purposes.\n   *\n   * Example:\n   * \"required\": true\n   */\n  required(value) {\n    var attr = this.attr;\n    attr.required = value === true;\n  }\n  /**\n   * This is the opposite of \"preserve-name\" and will result\n   * in dashes being removed from the attribute if set to true.\n   */\n  removeDashes(value) {\n    var attr = this.attr;\n    attr.removeDashes = value === true;\n  }\n  /**\n   * The description of the attribute. Only used for documentation.\n   */\n  description(value) {\n    this.attr.description = value;\n  }\n\n  /**\n   * The \"set-flag\" property allows a \"flag\" to be added to a Node instance\n   * at compile time if the attribute is found on the node. This is helpful\n   * if an attribute uses a pattern and a transformer wants to have a simple\n   * check to see if the Node has an attribute that matched the pattern.\n   *\n   * Example:\n   *\n   * \"set-flag\": \"myCustomFlag\"\n   *\n   * A Node instance can be checked if it has a flag set as shown below:\n   *\n   * if (node.hasFlag('myCustomFlag')) { ... }\n   *\n   *\n   */\n  setFlag(value) {\n    var attr = this.attr;\n    attr.setFlag = value;\n  }\n\n  /**\n   * The \"set-context-flag\" property allows a \"flag\" to be added to the CompilerContext instance\n   * at compile time if the attribute is found on the node. This is helpful\n   * if an attribute uses a pattern and a transformer wants to have a simple\n   * check to see if any Node in the template has an attribute that matched the pattern.\n   *\n   * Example:\n   *\n   * \"set-context-flag\": \"myCustomFlag\"\n   *\n   * A Node instance can be checked if it has a flag set as shown below:\n   *\n   * if (context.isFlagSet('myCustomFlag')) { ... }\n   *\n   *\n   */\n  setContextFlag(value) {\n    var attr = this.attr;\n    attr.setContextFlag = value;\n  }\n\n  /**\n   * An attribute can be marked for ignore. Ignored attributes\n   * will be ignored during compilation.\n   */\n  ignore(value) {\n    var attr = this.attr;\n    if (value === true) {\n      attr.ignore = true;\n    }\n  }\n\n  autocomplete(value) {\n    this.attr.autocomplete = value;\n  }\n\n  enum(value) {\n    this.attr.enum = value;\n  }\n\n  deprecated(value) {\n    this.attr.deprecated = value;\n  }\n\n  name(value) {\n    this.attr.name = value;\n  }\n\n  html(value) {\n    this.attr.html = value === true;\n  }\n}\n\nfunction loadAttributeFromProps(attrName, attrProps, dependencyChain) {\n  assert.ok(typeof attrName === \"string\");\n  assert.ok(dependencyChain, '\"dependencyChain\" is required');\n\n  var attr = new types.Attribute(attrName);\n\n  var attrLoader = new AttrLoader(attr, dependencyChain);\n\n  try {\n    attrLoader.load(attrProps);\n  } catch (err) {\n    throw createError(\n      'Unable to load attribute \"' +\n        attrName +\n        '\" (' +\n        dependencyChain +\n        \"): \" +\n        err,\n      err\n    );\n  }\n\n  return attr;\n}\n\nloadAttributeFromProps.isSupportedProperty = function (name) {\n  return hasOwnProperty.call(AttrLoader.prototype, name);\n};\n\nmodule.exports = loadAttributeFromProps;\n"],"file":"loadAttributeFromProps.js"}

package/dist/taglib/loader/loadAttributes.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/taglib/loader/loadAttributes.js"],"names":["ok","require","loaders","module","exports","loadAttributes","value","parent","dependencyChain","attrName","attrProps","attr","loadAttributeFromProps","append","addAttribute"],"mappings":"aAAA,IAAIA,EAAE,GAAGC,OAAO,CAAC,QAAD,CAAP,CAAkBD,EAA3B;AACA,IAAIE,OAAO,GAAGD,OAAO,CAAC,WAAD,CAArB;;AAEAE,MAAM,CAACC,OAAP,GAAiB,SAASC,cAAT,CAAwBC,KAAxB,EAA+BC,MAA/B,EAAuCC,eAAvC,EAAwD;AACvER,EAAAA,EAAE,CAACO,MAAD,CAAF;AACAP,EAAAA,EAAE,CAACQ,eAAD,CAAF;;AAEA,OAAK,MAAMC,QAAX,IAAuBH,KAAvB,EAA8B;AAC5B,UAAMI,SAAS,GAAGJ,KAAK,CAACG,QAAD,CAAvB;AACA,QAAIE,IAAI,GAAGT,OAAO,CAACU,sBAAR;AACTH,IAAAA,QADS;AAETC,IAAAA,SAFS;AAGTF,IAAAA,eAAe,CAACK,MAAhB,CAAuB,MAAMJ,QAA7B,CAHS,CAAX;;;AAMAF,IAAAA,MAAM,CAACO,YAAP,CAAoBH,IAApB;AACD;AACF,CAdD","sourcesContent":["var ok = require(\"assert\").ok;\nvar loaders = require(\"./loaders\");\n\nmodule.exports = function loadAttributes(value, parent, dependencyChain) {\n  ok(parent);\n  ok(dependencyChain);\n\n  for (const attrName in value) {\n    const attrProps = value[attrName];\n    var attr = loaders.loadAttributeFromProps(\n      attrName,\n      attrProps,\n      dependencyChain.append(\"@\" + attrName)\n    );\n\n    parent.addAttribute(attr);\n  }\n};\n"],"file":"loadAttributes.js"}

package/dist/taglib/loader/loadTagFromFile.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/taglib/loader/loadTagFromFile.js"],"names":["jsonFileReader","require","types","cache","loaders","ok","loadTagFromFile","filePath","tag","get","Tag","put","tagProps","readFileSync","loadTagFromProps","module","exports"],"mappings":"aAAA,IAAIA,cAAc,GAAGC,OAAO,CAAC,oBAAD,CAA5B;AACA,IAAIC,KAAK,GAAGD,OAAO,CAAC,SAAD,CAAnB;AACA,IAAIE,KAAK,GAAGF,OAAO,CAAC,SAAD,CAAnB;AACA,IAAIG,OAAO,GAAGH,OAAO,CAAC,WAAD,CAArB;;AAEA,IAAII,EAAE,GAAGJ,OAAO,CAAC,QAAD,CAAP,CAAkBI,EAA3B;;AAEA,SAASC,eAAT,CAAyBC,QAAzB,EAAmC;AACjCF,EAAAA,EAAE,CAACE,QAAD,EAAW,wBAAX,CAAF;;AAEA,MAAIC,GAAG,GAAGL,KAAK,CAACM,GAAN,CAAUF,QAAV,CAAV;;AAEA;AACA;AACA,MAAI,CAACC,GAAL,EAAU;AACRA,IAAAA,GAAG,GAAG,IAAIN,KAAK,CAACQ,GAAV,CAAcH,QAAd,CAAN;AACAJ,IAAAA,KAAK,CAACQ,GAAN,CAAUJ,QAAV,EAAoBC,GAApB;;AAEA,QAAII,QAAQ,GAAGZ,cAAc,CAACa,YAAf,CAA4BN,QAA5B,CAAf;AACAH,IAAAA,OAAO,CAACU,gBAAR,CAAyBN,GAAzB,EAA8BI,QAA9B;AACD;;AAED,SAAOJ,GAAP;AACD;;AAEDO,MAAM,CAACC,OAAP,GAAiBV,eAAjB","sourcesContent":["var jsonFileReader = require(\"./json-file-reader\");\nvar types = require(\"./types\");\nvar cache = require(\"./cache\");\nvar loaders = require(\"./loaders\");\n\nvar ok = require(\"assert\").ok;\n\nfunction loadTagFromFile(filePath) {\n  ok(filePath, '\"filePath\" is required');\n\n  var tag = cache.get(filePath);\n\n  // Only load a tag once by caching the loaded tags using the file\n  // system file path as the key\n  if (!tag) {\n    tag = new types.Tag(filePath);\n    cache.put(filePath, tag);\n\n    var tagProps = jsonFileReader.readFileSync(filePath);\n    loaders.loadTagFromProps(tag, tagProps);\n  }\n\n  return tag;\n}\n\nmodule.exports = loadTagFromFile;\n"],"file":"loadTagFromFile.js"}

package/dist/taglib/loader/loadTagFromProps.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/taglib/loader/loadTagFromProps.js"],"names":["ok","require","resolveFrom","silent","propertyHandlers","isObjectEmpty","nodePath","createError","taglibFS","types","loaders","markoModules","hasOwnProperty","Object","prototype","resolveRelative","dirname","value","removeDashes","str","replace","match","lower","toUpperCase","hasAttributes","tagProps","attributes","name","call","startsWith","normalizeHook","path","hook","TagLoader","constructor","tag","dependencyChain","filePath","dir","load","type","targetProperty","preserveName","toString","_handleVar","nestedVariable","nameFromAttribute","Error","addNestedVariable","parts","split","i","part","hasNestedTag","hasAttr","nestedTagTargetProperty","length","substring","attrProps","k","propNameDashes","isSupportedProperty","isSupportedAttributeProperty","keys","join","attrName","attr","loadAttributeFromProps","append","addAttribute","nestedTag","Tag","loadTagFromProps","isNestedTagRepeated","endsWith","slice","nestedTagName","isRepeated","addNestedTag","renderer","template","resolve","curFS","statSync","_","loadAttributes","migrator","migrate","Array","isArray","forEach","migrators","push","codeGenerator","translate","translator","nodeFactory","parse","parser","transformer","transform","transformers","analyze","analyzer","nestedTags","nestedTagDef","openTagOnly","description","autocomplete","parseOptions","deprecated","attributeGroups","concat","html","htmlType","featureFlags","tagLoader","err","module","exports"],"mappings":"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","sourcesContent":["\"use strict\";\n\nvar ok = require(\"assert\").ok;\nvar resolveFrom = require(\"resolve-from\").silent;\nvar propertyHandlers = require(\"property-handlers\");\nvar isObjectEmpty = require(\"raptor-util/isObjectEmpty\");\nvar nodePath = require(\"path\");\nvar createError = require(\"raptor-util/createError\");\nvar taglibFS = require(\"../fs\");\nvar types = require(\"./types\");\nvar loaders = require(\"./loaders\");\nvar markoModules = require(\"../../../modules\");\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nfunction resolveRelative(dirname, value) {\n  return value[0] === \".\" ? resolveFrom(dirname, value) : value;\n}\n\nfunction removeDashes(str) {\n  return str.replace(/-([a-z])/g, function (match, lower) {\n    return lower.toUpperCase();\n  });\n}\n\nfunction hasAttributes(tagProps) {\n  if (tagProps.attributes != null) {\n    return true;\n  }\n\n  for (var name in tagProps) {\n    if (hasOwnProperty.call(tagProps, name) && name.startsWith(\"@\")) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\nfunction normalizeHook(dirname, value) {\n  if (typeof value === \"string\") {\n    value = resolveRelative(dirname, value);\n    return {\n      path: value,\n      get hook() {\n        return markoModules.require(value);\n      }\n    };\n  }\n  return { hook: value };\n}\n\n/**\n * We load tag definition using this class. Properties in the taglib\n * definition (which is just a JavaScript object with properties)\n * are mapped to handler methods in an instance of this type.\n *\n * @param {Tag} tag The initially empty Tag instance that we populate\n * @param {String} dirname The full file system path associated with the tag being loaded\n * @param {String} path An informational path associated with this tag (used for error reporting)\n */\nclass TagLoader {\n  constructor(tag, dependencyChain) {\n    this.tag = tag;\n    this.dependencyChain = dependencyChain;\n\n    this.filePath = tag.filePath;\n    this.dirname = tag.dir || tag.dirname;\n  }\n\n  load(tagProps) {\n    if (!hasAttributes(tagProps)) {\n      // allow any attributes if no attributes are declared\n      tagProps.attributes = {\n        \"*\": {\n          type: \"string\",\n          targetProperty: null,\n          preserveName: false\n        }\n      };\n    }\n\n    propertyHandlers(tagProps, this, this.dependencyChain.toString());\n  }\n\n  _handleVar(value, dependencyChain) {\n    var tag = this.tag;\n\n    var nestedVariable;\n\n    if (typeof value === \"string\") {\n      nestedVariable = {\n        name: value\n      };\n    } else {\n      nestedVariable = {};\n\n      propertyHandlers(\n        value,\n        {\n          name: function (value) {\n            nestedVariable.name = value;\n          },\n\n          nameFromAttribute: function (value) {\n            nestedVariable.nameFromAttribute = value;\n          }\n        },\n        dependencyChain.toString()\n      );\n\n      if (!nestedVariable.name && !nestedVariable.nameFromAttribute) {\n        throw new Error(\n          'The \"name\" or \"name-from-attribute\" attribute is required for a nested variable (' +\n            dependencyChain +\n            \")\"\n        );\n      }\n    }\n\n    tag.addNestedVariable(nestedVariable);\n  }\n\n  /**\n   * This is handler is for any properties that didn't match\n   * one of the default property handlers. This is used to\n   * match properties in the form of \"@attr_name\" or\n   * \"<nested_tag_name>\"\n   */\n  \"*\"(name, value) {\n    var tag = this.tag;\n    var dependencyChain = this.dependencyChain;\n    var parts = name.split(/\\s+|\\s+[,]\\s+/);\n\n    var i;\n    var part;\n\n    var hasNestedTag = false;\n    var hasAttr = false;\n    var nestedTagTargetProperty = null;\n\n    // We do one pass to figure out if there is an\n    // attribute or nested tag or both\n    for (i = 0; i < parts.length; i++) {\n      part = parts[i];\n      if (part.startsWith(\"@\")) {\n        hasAttr = true;\n\n        if (i === 0) {\n          // Use the first attribute value as the name of the target property\n          nestedTagTargetProperty = part.substring(1);\n        }\n      } else if (part.startsWith(\"<\")) {\n        hasNestedTag = true;\n      } else {\n        // Unmatched property that is not an attribute or a\n        // nested tag\n        return false;\n      }\n    }\n\n    var attrProps = {};\n    var tagProps = {};\n    var k;\n\n    if (value != null && typeof value === \"object\") {\n      for (k in value) {\n        if (hasOwnProperty.call(value, k)) {\n          if (k.startsWith(\"@\") || k.startsWith(\"<\")) {\n            // Move over all of the attributes and nested tags\n            // to the tag definition.\n            tagProps[k] = value[k];\n            delete value[k];\n          } else {\n            // The property is not a shorthand attribute or shorthand\n            // tag so move it over to either the tag definition\n            // or the attribute definition or both the tag definition\n            // and attribute definition.\n            var propNameDashes = removeDashes(k);\n\n            if (\n              isSupportedProperty(propNameDashes) &&\n              loaders.isSupportedAttributeProperty(propNameDashes)\n            ) {\n              // Move over all of the properties that are associated with a tag\n              // and attribute\n              tagProps[k] = value[k];\n              attrProps[k] = value[k];\n              delete value[k];\n            } else if (isSupportedProperty(propNameDashes)) {\n              // Move over all of the properties that are associated with a tag\n              tagProps[k] = value[k];\n              delete value[k];\n            } else if (loaders.isSupportedAttributeProperty(propNameDashes)) {\n              // Move over all of the properties that are associated with an attr\n              attrProps[k] = value[k];\n              delete value[k];\n            }\n          }\n        }\n      }\n\n      // If there are any left over properties then something is wrong\n      // with the user's taglib.\n      if (!isObjectEmpty(value)) {\n        throw new Error(\n          \"Unsupported properties of [\" + Object.keys(value).join(\", \") + \"]\"\n        );\n      }\n\n      var type = attrProps.type;\n      if (!type && hasAttr && hasNestedTag) {\n        // If we have an attribute and a nested tag then default\n        // the attribute type to \"expression\"\n        attrProps.type = \"expression\";\n      }\n    } else if (typeof value === \"string\") {\n      if (hasNestedTag && hasAttr) {\n        tagProps = attrProps = {\n          type: value\n        };\n      } else if (hasNestedTag) {\n        tagProps = {\n          type: value\n        };\n      } else {\n        attrProps = {\n          type: value\n        };\n      }\n    }\n\n    // Now that we have separated out attribute properties and tag properties\n    // we need to create the actual attributes and nested tags\n    for (i = 0; i < parts.length; i++) {\n      part = parts[i];\n      if (part.startsWith(\"@\")) {\n        // This is a shorthand attribute\n        var attrName = part.substring(1);\n\n        var attr = loaders.loadAttributeFromProps(\n          attrName,\n          attrProps,\n          dependencyChain.append(part)\n        );\n\n        tag.addAttribute(attr);\n      } else if (part.startsWith(\"<\")) {\n        // This is a shorthand nested tag\n        let nestedTag = new types.Tag(this.filePath);\n\n        loadTagFromProps(nestedTag, tagProps, dependencyChain.append(part));\n\n        // We use the '[]' suffix to indicate that a nested tag\n        // can be repeated\n        var isNestedTagRepeated = false;\n        if (part.endsWith(\"[]\")) {\n          isNestedTagRepeated = true;\n          part = part.slice(0, -2);\n        }\n\n        var nestedTagName = part.substring(1, part.length - 1);\n        nestedTag.name = nestedTagName;\n        nestedTag.isRepeated = nestedTag.isRepeated || isNestedTagRepeated;\n        // Use the name of the attribute as the target property unless\n        // this target property was explicitly provided\n        nestedTag.targetProperty =\n          attrProps.targetProperty || nestedTagTargetProperty;\n        tag.addNestedTag(nestedTag);\n\n        if (!nestedTag.isRepeated) {\n          let attr = loaders.loadAttributeFromProps(\n            nestedTag.targetProperty,\n            { type: \"object\" },\n            dependencyChain.append(part)\n          );\n\n          tag.addAttribute(attr);\n        }\n      } else {\n        return false;\n      }\n    }\n  }\n\n  /**\n   * The tag name\n   * @param {String} value The tag name\n   */\n  name(value) {\n    var tag = this.tag;\n    tag.name = value;\n  }\n\n  /**\n   * The path to the renderer JS module to use for this tag.\n   *\n   * NOTE: We use the equivalent of require.resolve to resolve the JS module\n   * \t\t and use the tag directory as the \"from\".\n   *\n   * @param {String} value The renderer path\n   */\n  renderer(value) {\n    this.tag.renderer = resolveRelative(this.dirname, value);\n  }\n\n  /**\n   * A tag can use a renderer or a template to do the rendering. If\n   * a template is provided then the value should be the path to the\n   * template to use to render the custom tag.\n   */\n  template(value) {\n    var tag = this.tag;\n    var dirname = this.dirname;\n\n    var path = nodePath.resolve(dirname, value);\n\n    try {\n      taglibFS.curFS.statSync(path);\n      tag.template = path;\n    } catch (_) {\n      throw new Error('Template at path \"' + path + '\" does not exist.');\n    }\n  }\n\n  /**\n   * An Object where each property maps to an attribute definition.\n   * The property key will be the attribute name and the property value\n   * will be the attribute definition. Example:\n   * {\n   *     \"attributes\": {\n   *         \"foo\": \"string\",\n   *         \"bar\": \"expression\"\n   *     }\n   * }\n   */\n  attributes(value) {\n    var tag = this.tag;\n\n    loaders.loadAttributes(\n      value,\n      tag,\n      this.dependencyChain.append(\"attributes\")\n    );\n  }\n\n  /**\n   * Deprecated\n   */\n  migrator(value) {\n    this.migrate(value);\n  }\n  /**\n   * A custom tag can be mapped to module that is used\n   * migrate deprecated features to modern features.\n   */\n  migrate(value) {\n    if (Array.isArray(value)) {\n      value.forEach(this.migrate, this);\n    } else {\n      this.tag.migrators.push(normalizeHook(this.dirname, value));\n    }\n  }\n\n  /**\n   * Deprecated\n   */\n  codeGenerator(value) {\n    this.translate(value);\n  }\n\n  /**\n   * A custom tag can be mapped to module that is is used\n   * to generate compile-time code for the custom tag. A\n   * node type is created based on the methods and methods\n   * exported by the code codegen module.\n   */\n  translate(value) {\n    this.tag.translator = normalizeHook(this.dirname, value);\n  }\n\n  /**\n   * Deprecated\n   */\n  nodeFactory(value) {\n    this.parse(value);\n  }\n\n  /**\n   * A custom tag can be mapped to a compile-time Node that gets\n   * added to the parsed Abstract Syntax Tree (AST). The Node can\n   * then generate custom JS code at compile time. The value\n   * should be a path to a JS module that gets resolved using the\n   * equivalent of require.resolve(path)\n   */\n  parse(value) {\n    this.tag.parser = normalizeHook(this.dirname, value);\n  }\n\n  /**\n   * Deprecated\n   */\n  transformer(value) {\n    this.transform(value);\n  }\n\n  /**\n   * If a custom tag has an associated transformer then the transformer\n   * will be called on the compile-time Node. The transformer can manipulate\n   * the AST using the DOM-like API to change how the code gets generated.\n   */\n  transform(value) {\n    if (Array.isArray(value)) {\n      value.forEach(this.transform, this);\n    } else {\n      this.tag.transformers.push(normalizeHook(this.dirname, value));\n    }\n  }\n\n  /**\n   * A custom tag can be mapped to module that is is used\n   * to analyze code and cache the result in memory.\n   * This analysis data should be read by translate hooks.\n   */\n  analyze(value) {\n    this.tag.analyzer = normalizeHook(this.dirname, value);\n  }\n\n  /**\n   * The tag type.\n   */\n  type(value) {\n    var tag = this.tag;\n    tag.type = value;\n  }\n\n  isRepeated(value) {\n    var tag = this.tag;\n    tag.isRepeated = value;\n  }\n\n  targetProperty(value) {\n    var tag = this.tag;\n    tag.targetProperty = value;\n  }\n\n  /**\n   * Declare a nested tag.\n   *\n   * Example:\n   * {\n   *     ...\n   *     \"nested-tags\": {\n   *        \"tab\": {\n   *            \"target-property\": \"tabs\",\n   *            \"is-repeated\": true\n   *        }\n   *     }\n   * }\n   */\n  nestedTags(value) {\n    var filePath = this.filePath;\n    var tag = this.tag;\n\n    for (const nestedTagName in value) {\n      const nestedTagDef = value[nestedTagName];\n      var dependencyChain = this.dependencyChain.append(\n        `nestedTags[\"${nestedTagName}\"]`\n      );\n      var nestedTag = new types.Tag(filePath);\n\n      loadTagFromProps(nestedTag, nestedTagDef, dependencyChain);\n\n      nestedTag.name = nestedTagName;\n      tag.addNestedTag(nestedTag);\n\n      if (!nestedTag.isRepeated) {\n        let attr = loaders.loadAttributeFromProps(\n          nestedTag.targetProperty,\n          { type: \"object\" },\n          dependencyChain\n        );\n\n        tag.addAttribute(attr);\n      }\n    }\n  }\n\n  openTagOnly(value) {\n    this.tag.openTagOnly = value;\n  }\n\n  /**\n   * The description of the tag. Only used for documentation.\n   */\n  description(value) {\n    this.tag.description = value;\n  }\n\n  autocomplete(value) {\n    this.tag.autocomplete = value;\n  }\n\n  parseOptions(value) {\n    this.tag.parseOptions = value;\n  }\n\n  deprecated(value) {\n    this.tag.deprecated = value;\n  }\n\n  attributeGroups(value) {\n    if (!value) {\n      return;\n    }\n\n    var attributeGroups =\n      this.tag.attributeGroups || (this.tag.attributeGroups = []);\n    this.tag.attributeGroups = attributeGroups.concat(value);\n  }\n\n  html(value) {\n    this.tag.html = value === true;\n  }\n\n  htmlType(value) {\n    this.tag.htmlType = value;\n  }\n\n  featureFlags(value) {\n    this.tag.featureFlags = value;\n  }\n}\n\nfunction isSupportedProperty(name) {\n  return hasOwnProperty.call(TagLoader.prototype, name);\n}\n\nfunction loadTagFromProps(tag, tagProps, dependencyChain) {\n  ok(typeof tagProps === \"object\", 'Invalid \"tagProps\"');\n  ok(dependencyChain, '\"dependencyChain\" is required');\n\n  var tagLoader = new TagLoader(tag, dependencyChain);\n\n  try {\n    tagLoader.load(tagProps);\n  } catch (err) {\n    throw createError(\n      \"Unable to load tag (\" + dependencyChain + \"): \" + err,\n      err\n    );\n  }\n\n  return tag;\n}\n\nmodule.exports = loadTagFromProps;\n\nloadTagFromProps.isSupportedProperty = isSupportedProperty;\n"],"file":"loadTagFromProps.js"}

package/dist/taglib/loader/loadTaglibFromFile.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/taglib/loader/loadTaglibFromFile.js"],"names":["jsonFileReader","require","types","cache","loaders","ok","loadFromFile","filePath","taglib","get","Taglib","put","taglibProps","readFileSync","loadTaglibFromProps","module","exports"],"mappings":"aAAA,IAAIA,cAAc,GAAGC,OAAO,CAAC,oBAAD,CAA5B;AACA,IAAIC,KAAK,GAAGD,OAAO,CAAC,SAAD,CAAnB;AACA,IAAIE,KAAK,GAAGF,OAAO,CAAC,SAAD,CAAnB;AACA,IAAIG,OAAO,GAAGH,OAAO,CAAC,WAAD,CAArB;;AAEA,IAAII,EAAE,GAAGJ,OAAO,CAAC,QAAD,CAAP,CAAkBI,EAA3B;;AAEA,SAASC,YAAT,CAAsBC,QAAtB,EAAgC;AAC9BF,EAAAA,EAAE,CAACE,QAAD,EAAW,wBAAX,CAAF;;AAEA,MAAIC,MAAM,GAAGL,KAAK,CAACM,GAAN,CAAUF,QAAV,CAAb;;AAEA;AACA;AACA,MAAI,CAACC,MAAL,EAAa;AACXA,IAAAA,MAAM,GAAG,IAAIN,KAAK,CAACQ,MAAV,CAAiBH,QAAjB,CAAT;AACAJ,IAAAA,KAAK,CAACQ,GAAN,CAAUJ,QAAV,EAAoBC,MAApB;;AAEA,QAAII,WAAW,GAAGZ,cAAc,CAACa,YAAf,CAA4BN,QAA5B,CAAlB;AACAH,IAAAA,OAAO,CAACU,mBAAR,CAA4BN,MAA5B,EAAoCI,WAApC;AACD;;AAED,SAAOJ,MAAP;AACD;;AAEDO,MAAM,CAACC,OAAP,GAAiBV,YAAjB","sourcesContent":["var jsonFileReader = require(\"./json-file-reader\");\nvar types = require(\"./types\");\nvar cache = require(\"./cache\");\nvar loaders = require(\"./loaders\");\n\nvar ok = require(\"assert\").ok;\n\nfunction loadFromFile(filePath) {\n  ok(filePath, '\"filePath\" is required');\n\n  var taglib = cache.get(filePath);\n\n  // Only load a taglib once by caching the loaded taglibs using the file\n  // system file path as the key\n  if (!taglib) {\n    taglib = new types.Taglib(filePath);\n    cache.put(filePath, taglib);\n\n    var taglibProps = jsonFileReader.readFileSync(filePath);\n    loaders.loadTaglibFromProps(taglib, taglibProps);\n  }\n\n  return taglib;\n}\n\nmodule.exports = loadFromFile;\n"],"file":"loadTaglibFromFile.js"}

package/dist/taglib/loader/loadTaglibFromProps.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/taglib/loader/loadTaglibFromProps.js"],"names":["ok","require","resolveFrom","silent","nodePath","types","taglibFS","scanTagsDir","propertyHandlers","jsonFileReader","DependencyChain","createError","loaders","markoModules","hasOwnProperty","Object","prototype","resolveRelative","dirname","value","normalizeHook","path","hook","TaglibLoader","constructor","taglib","dependencyChain","filePath","load","taglibProps","toString","id","packageJsonPath","join","pkg","readFileSync","name","e","_handleTag","tagName","tagProps","tagFilePath","tag","resolve","curFS","statSync","_","Error","Tag","append","loadTagFromProps","undefined","addTag","startsWith","slice","attrKey","substring","attr","loadAttributeFromProps","key","addAttribute","attributes","keys","forEach","attrName","attrDef","tags","call","tagsDir","dir","Array","isArray","i","length","taglibImports","imports","importPath","curImport","basename","packagePath","packageDir","dependencies","dependencyNames","j","dependencyName","addImport","migrator","migrate","migrators","push","translate","translator","taglibId","transformer","transform","transformers","attributeGroups","attrGroupName","attrGroup","attrGroupDependencyChain","rawAttrGroup","rawAttrDef","loadTaglibFromProps","taglibLoader","err","module","exports"],"mappings":"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","sourcesContent":["\"use strict\";\n\nvar ok = require(\"assert\").ok;\nvar resolveFrom = require(\"resolve-from\").silent;\nvar nodePath = require(\"path\");\nvar types = require(\"./types\");\nvar taglibFS = require(\"../fs\");\nvar scanTagsDir = require(\"./scanTagsDir\");\nvar propertyHandlers = require(\"property-handlers\");\nvar jsonFileReader = require(\"./json-file-reader\");\nvar DependencyChain = require(\"./DependencyChain\");\nvar createError = require(\"raptor-util/createError\");\nvar loaders = require(\"./loaders\");\nvar markoModules = require(\"../../../modules\");\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nfunction resolveRelative(dirname, value) {\n  return value[0] === \".\" ? resolveFrom(dirname, value) : value;\n}\n\nfunction normalizeHook(dirname, value) {\n  if (typeof value === \"string\") {\n    value = resolveRelative(dirname, value);\n    return {\n      path: value,\n      get hook() {\n        return markoModules.require(value);\n      }\n    };\n  }\n  return { hook: value };\n}\n\n/**\n * We load a taglib definion using this class. Properties in the taglib\n * definition (which is just a JavaScript object with properties)\n * are mapped to handler methods in an instance of this type.\n *\n *\n * @param {Taglib} taglib The initially empty Taglib instance that we will populate\n * @param {String} path The file system path to the taglib that we are loading\n */\nclass TaglibLoader {\n  constructor(taglib, dependencyChain) {\n    ok(\n      dependencyChain instanceof DependencyChain,\n      '\"dependencyChain\" is not valid'\n    );\n\n    this.dependencyChain = dependencyChain;\n\n    this.taglib = taglib;\n    this.filePath = taglib.filePath;\n    this.dirname = taglib.dirname;\n  }\n\n  load(taglibProps) {\n    var taglib = this.taglib;\n\n    propertyHandlers(taglibProps, this, this.dependencyChain.toString());\n\n    if (!taglib.id) {\n      // Fixes #73\n      // See if there is a package.json in the same directory as the taglib file.\n      // If so, and if that package.json file has a \"name\" property then we will\n      // use the the name as the \"taglib ID\". The taglib ID is used to uniquely\n      // identity a taglib (ignoring version) and it is used to prevent the same\n      // taglib from being loaded multiple times.\n      //\n      // Using the file path as the taglib ID doesn't work so well since we might find\n      // the same taglib multiple times in the Node.js module search path with\n      // different paths.\n      var filePath = this.filePath;\n      var dirname = this.dirname;\n\n      var packageJsonPath = nodePath.join(dirname, \"package.json\");\n\n      try {\n        var pkg = jsonFileReader.readFileSync(packageJsonPath);\n        taglib.id = pkg.name;\n      } catch (e) {\n        /* ignore error */\n      }\n\n      if (!taglib.id) {\n        taglib.id = filePath;\n      }\n    }\n  }\n\n  _handleTag(tagName, value, dependencyChain) {\n    var tagProps;\n    var tagFilePath = this.filePath;\n\n    var tag;\n\n    if (typeof value === \"string\") {\n      tagFilePath = nodePath.resolve(this.dirname, value);\n\n      try {\n        taglibFS.curFS.statSync(tagFilePath);\n      } catch (_) {\n        throw new Error(\n          'Tag at path \"' +\n            tagFilePath +\n            '\" does not exist. (' +\n            dependencyChain +\n            \")\"\n        );\n      }\n\n      tag = new types.Tag(tagFilePath);\n\n      tagProps = jsonFileReader.readFileSync(tagFilePath);\n      dependencyChain = dependencyChain.append(tagFilePath);\n    } else {\n      tag = new types.Tag(this.filePath);\n      tagProps = value;\n    }\n\n    loaders.loadTagFromProps(tag, tagProps, dependencyChain);\n\n    if (tag.name === undefined) {\n      tag.name = tagName;\n    }\n\n    this.taglib.addTag(tag);\n  }\n\n  // We register a wildcard handler to handle \"@my-attr\" and \"<my-tag>\"\n  // properties (shorthand syntax)\n  \"*\"(name, value) {\n    var taglib = this.taglib;\n    var filePath = this.filePath;\n\n    if (name.startsWith(\"<\")) {\n      let tagName = name.slice(1, -1);\n      this._handleTag(tagName, value, this.dependencyChain.append(name));\n    } else if (name.startsWith(\"@\")) {\n      var attrKey = name.substring(1);\n\n      var attr = loaders.loadAttributeFromProps(\n        attrKey,\n        value,\n        this.dependencyChain.append(\"@\" + attrKey)\n      );\n\n      attr.filePath = filePath;\n      attr.key = attrKey;\n\n      taglib.addAttribute(attr);\n    } else {\n      return false;\n    }\n  }\n\n  attributes(value) {\n    // The value of the \"attributes\" property will be an object\n    // where each property maps to an attribute definition. Since these\n    // attributes are on the taglib they will be \"global\" attribute\n    // defintions.\n    //\n    // The property key will be the attribute name and the property value\n    // will be the attribute definition. Example:\n    // {\n    //     \"attributes\": {\n    //         \"foo\": \"string\",\n    //         \"bar\": \"expression\"\n    //     }\n    // }\n    var taglib = this.taglib;\n\n    Object.keys(value).forEach(attrName => {\n      var attrDef = value[attrName];\n\n      var attr = loaders.loadAttributeFromProps(\n        attrName,\n        attrDef,\n        this.dependencyChain.append(\"@\" + attrName)\n      );\n\n      attr.key = attrName;\n\n      taglib.addAttribute(attr);\n    });\n  }\n  tags(tags) {\n    // The value of the \"tags\" property will be an object\n    // where each property maps to an attribute definition. The property\n    // key will be the tag name and the property value\n    // will be the tag definition. Example:\n    // {\n    //     \"tags\": {\n    //         \"foo\": {\n    //             \"attributes\": { ... }\n    //         },\n    //         \"bar\": {\n    //             \"attributes\": { ... }\n    //         },\n    //     }\n    // }\n\n    for (var tagName in tags) {\n      if (hasOwnProperty.call(tags, tagName)) {\n        this._handleTag(\n          tagName,\n          tags[tagName],\n          this.dependencyChain.append(\"tags.\" + tagName)\n        );\n      }\n    }\n  }\n  tagsDir(dir) {\n    // The \"tags-dir\" property is used to supporting scanning\n    // of a directory to discover custom tags. Scanning a directory\n    // is a much simpler way for a developer to create custom tags.\n    // Only one tag is allowed per directory and the directory name\n    // corresponds to the tag name. We only search for directories\n    // one level deep.\n    var taglib = this.taglib;\n    var path = this.filePath;\n    var dirname = this.dirname;\n\n    taglib.tagsDir = dir;\n\n    if (dir != null) {\n      if (Array.isArray(dir)) {\n        for (var i = 0; i < dir.length; i++) {\n          scanTagsDir(\n            path,\n            dirname,\n            dir[i],\n            taglib,\n            this.dependencyChain.append(`tags-dir[${i}]`)\n          );\n        }\n      } else {\n        scanTagsDir(\n          path,\n          dirname,\n          dir,\n          taglib,\n          this.dependencyChain.append(`tags-dir`)\n        );\n      }\n    }\n  }\n\n  taglibImports(imports) {\n    // The \"taglib-imports\" property allows another taglib to be imported\n    // into this taglib so that the tags defined in the imported taglib\n    // will be part of this taglib.\n    //\n    // NOTE: If a taglib import refers to a package.json file then we read\n    //       the package.json file and automatically import *all* of the\n    //       taglibs from the installed modules found in the \"dependencies\"\n    //       section\n    var taglib = this.taglib;\n    var dirname = this.dirname;\n    var importPath;\n\n    if (imports && Array.isArray(imports)) {\n      for (var i = 0; i < imports.length; i++) {\n        var curImport = imports[i];\n        if (typeof curImport === \"string\") {\n          var basename = nodePath.basename(curImport);\n          if (basename === \"package.json\") {\n            var packagePath = resolveFrom(dirname, curImport);\n            var packageDir = nodePath.dirname(packagePath);\n            var pkg = jsonFileReader.readFileSync(packagePath);\n            var dependencies = pkg.dependencies;\n            if (dependencies) {\n              var dependencyNames = Object.keys(dependencies);\n              for (var j = 0; j < dependencyNames.length; j++) {\n                var dependencyName = dependencyNames[j];\n\n                importPath = resolveFrom(\n                  packageDir,\n                  nodePath.join(dependencyName, \"marko.json\")\n                );\n\n                if (importPath) {\n                  taglib.addImport(importPath);\n                }\n              }\n            }\n          } else {\n            importPath = resolveFrom(dirname, curImport);\n            if (importPath) {\n              taglib.addImport(importPath);\n            } else {\n              throw new Error(\n                \"Import not found: \" + curImport + \" (from \" + dirname + \")\"\n              );\n            }\n          }\n        }\n      }\n    }\n  }\n\n  /**\n   * Deprecated\n   */\n  migrator(value) {\n    this.migrate(value);\n  }\n  /**\n   * A taglib can be mapped to module that is used\n   * migrate deprecated features to modern features across the entire template.\n   */\n  migrate(value) {\n    if (Array.isArray(value)) {\n      value.forEach(this.migrate, this);\n    } else {\n      this.taglib.migrators.push(normalizeHook(this.dirname, value));\n    }\n  }\n\n  /**\n   * Exposes a babel visitor to perform additional translations on the entire ast.\n   */\n  translate(value) {\n    this.taglib.translator = normalizeHook(this.dirname, value);\n  }\n\n  /**\n   * Allows an ID to be explicitly assigned to a taglib.\n   * The taglib ID is used to prevent the same taglib  (even if different versions)\n   * from being loaded multiple times.\n   *\n   * NOTE: Introduced as part of fix for #73\n   *\n   * @param  {String} value The taglib ID\n   */\n  taglibId(value) {\n    var taglib = this.taglib;\n    taglib.id = value;\n  }\n\n  /**\n   * Deprecated\n   */\n  transformer(value) {\n    this.transform(value);\n  }\n  /**\n   * If a custom tag has an associated transformer then the transformer\n   * will be called on the compile-time Node. The transformer can manipulate\n   * the AST using the DOM-like API to change how the code gets generated.\n   */\n  transform(value) {\n    if (Array.isArray(value)) {\n      value.forEach(this.transform, this);\n    } else {\n      this.taglib.transformers.push(normalizeHook(this.dirname, value));\n    }\n  }\n\n  attributeGroups(value) {\n    let taglib = this.taglib;\n    let attributeGroups =\n      taglib.attributeGroups || (taglib.attributeGroups = {});\n    let dependencyChain = this.dependencyChain.append(\"attribute-groups\");\n\n    Object.keys(value).forEach(attrGroupName => {\n      let attrGroup = (attributeGroups[attrGroupName] = {});\n      let attrGroupDependencyChain = dependencyChain.append(attrGroupName);\n\n      let rawAttrGroup = value[attrGroupName];\n\n      Object.keys(rawAttrGroup).forEach(attrName => {\n        var rawAttrDef = rawAttrGroup[attrName];\n\n        let attr = loaders.loadAttributeFromProps(\n          attrName,\n          rawAttrDef,\n          attrGroupDependencyChain.append(\"@\" + attrName)\n        );\n\n        attrGroup[attrName] = attr;\n      });\n    });\n  }\n}\n\nfunction loadTaglibFromProps(taglib, taglibProps, dependencyChain) {\n  ok(taglib, '\"taglib\" is required');\n  ok(taglibProps, '\"taglibProps\" is required');\n  ok(taglib.filePath, '\"taglib.filePath\" is required');\n\n  if (!dependencyChain) {\n    dependencyChain = new DependencyChain([taglib.filePath]);\n  }\n\n  var taglibLoader = new TaglibLoader(taglib, dependencyChain);\n\n  try {\n    taglibLoader.load(taglibProps);\n  } catch (err) {\n    throw createError(\n      \"Unable to load taglib (\" + dependencyChain + \"): \" + err,\n      err\n    );\n  }\n\n  return taglib;\n}\n\nmodule.exports = loadTaglibFromProps;\n"],"file":"loadTaglibFromProps.js"}

package/dist/taglib/loader/loaders.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/taglib/loader/loaders.js"],"names":["types","require","isSupportedAttributeProperty","propertyName","exports","loadAttributeFromProps","isSupportedProperty","isSupportedTagProperty","loadTagFromProps","createTaglib","taglibPath","Taglib","loadTagFromFile","loadTaglibFromProps","loadTaglibFromFile","loadAttributes"],"mappings":"aAAA,IAAIA,KAAK,GAAGC,OAAO,CAAC,SAAD,CAAnB;;AAEA,SAASC,4BAAT,CAAsCC,YAAtC,EAAoD;AAClD,SAAOC,OAAO,CAACC,sBAAR,CAA+BC,mBAA/B,CAAmDH,YAAnD,CAAP;AACD;;AAED,SAASI,sBAAT,CAAgCJ,YAAhC,EAA8C;AAC5C,SAAOC,OAAO,CAACI,gBAAR,CAAyBF,mBAAzB,CAA6CH,YAA7C,CAAP;AACD;;AAED,SAASM,YAAT,CAAsBC,UAAtB,EAAkC;AAChC,SAAO,IAAIV,KAAK,CAACW,MAAV,CAAiBD,UAAjB,CAAP;AACD;;AAEDN,OAAO,CAACK,YAAR,GAAuBA,YAAvB;AACAL,OAAO,CAACC,sBAAR,GAAiCJ,OAAO,CAAC,0BAAD,CAAxC;AACAG,OAAO,CAACI,gBAAR,GAA2BP,OAAO,CAAC,oBAAD,CAAlC;AACAG,OAAO,CAACQ,eAAR,GAA0BX,OAAO,CAAC,mBAAD,CAAjC;AACAG,OAAO,CAACS,mBAAR,GAA8BZ,OAAO,CAAC,uBAAD,CAArC;AACAG,OAAO,CAACU,kBAAR,GAA6Bb,OAAO,CAAC,sBAAD,CAApC;AACAG,OAAO,CAACW,cAAR,GAAyBd,OAAO,CAAC,kBAAD,CAAhC;AACAG,OAAO,CAACF,4BAAR,GAAuCA,4BAAvC;AACAE,OAAO,CAACG,sBAAR,GAAiCA,sBAAjC","sourcesContent":["var types = require(\"./types\");\n\nfunction isSupportedAttributeProperty(propertyName) {\n  return exports.loadAttributeFromProps.isSupportedProperty(propertyName);\n}\n\nfunction isSupportedTagProperty(propertyName) {\n  return exports.loadTagFromProps.isSupportedProperty(propertyName);\n}\n\nfunction createTaglib(taglibPath) {\n  return new types.Taglib(taglibPath);\n}\n\nexports.createTaglib = createTaglib;\nexports.loadAttributeFromProps = require(\"./loadAttributeFromProps\");\nexports.loadTagFromProps = require(\"./loadTagFromProps\");\nexports.loadTagFromFile = require(\"./loadTagFromFile\");\nexports.loadTaglibFromProps = require(\"./loadTaglibFromProps\");\nexports.loadTaglibFromFile = require(\"./loadTaglibFromFile\");\nexports.loadAttributes = require(\"./loadAttributes\");\nexports.isSupportedAttributeProperty = isSupportedAttributeProperty;\nexports.isSupportedTagProperty = isSupportedTagProperty;\n"],"file":"loaders.js"}

package/dist/taglib/loader/scanTagsDir.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/taglib/loader/scanTagsDir.js"],"names":["nodePath","require","taglibFS","jsonFileReader","tagDefFromCode","loaders","fsReadOptions","encoding","extend","types","tagFileTypes","searchFiles","name","type","createDefaultTagDef","attributes","targetProperty","preserveName","getFileMap","dirname","fileMap","files","curFS","readdirSync","forEach","file","extName","extname","baseName","slice","length","fullPath","join","__path","getPath","filename","js","key","findAndSetFile","tagDef","tagDirname","statSync","isDirectory","_","tagName","basename","i","repeatedName","replace","path","hasFile","module","exports","scanTagsDir","tagsConfigPath","tagsConfigDirname","dir","taglib","dependencyChain","prefix","resolve","children","len","childFilename","tagJsonPath","ext","template","hasTagJson","readFileSync","fileWasSet","Error","JSON","stringify","renderer","templateCode","String","extractedTagDef","extractTagDef","tagDependencyChain","append","tag","Tag","loadTagFromProps","addTag"],"mappings":"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","sourcesContent":["\"use strict\";\n\nconst nodePath = require(\"path\");\nconst taglibFS = require(\"../fs\");\nconst jsonFileReader = require(\"./json-file-reader\");\nconst tagDefFromCode = require(\"./tag-def-from-code\");\nconst loaders = require(\"./loaders\");\nconst fsReadOptions = { encoding: \"utf8\" };\nconst extend = require(\"raptor-util/extend\");\nconst types = require(\"./types\");\n\nconst tagFileTypes = [\n  \"template\",\n  \"renderer\",\n  \"transform\",\n  \"transformer\",\n  \"code-generator\",\n  \"translate\",\n  \"node-factory\",\n  \"parse\"\n];\n\nconst searchFiles = [\n  { name: \"index.marko\", type: \"template\" },\n  { name: \"renderer\", type: \"renderer\" },\n  { name: \"index\", type: \"renderer\" },\n  { name: \"template.marko\", type: \"template\" },\n  { name: \"template.html\", type: \"template\" },\n  { name: \"code-generator\", type: \"translate\" },\n  { name: \"translate\", type: \"translate\" },\n  { name: \"node-factory\", type: \"parse\" },\n  { name: \"parse\", type: \"parse\" },\n  { name: \"transformer\", type: \"transform\" },\n  { name: \"transform\", type: \"transform\" }\n];\n\nfunction createDefaultTagDef() {\n  return {\n    attributes: {\n      \"*\": {\n        type: \"string\",\n        targetProperty: null,\n        preserveName: false\n      }\n    }\n  };\n}\n\nfunction getFileMap(dirname) {\n  let fileMap = {};\n  let files = taglibFS.curFS.readdirSync(dirname);\n\n  files.forEach(file => {\n    let extName = nodePath.extname(file);\n    let baseName = file.slice(0, -1 * extName.length);\n    let fullPath = nodePath.join(dirname, file);\n    fileMap[baseName] = fileMap[baseName] || {};\n    fileMap[baseName][extName] = fullPath;\n    fileMap[file] = fileMap[file] || {};\n    fileMap[file].__path = fullPath;\n  });\n\n  return fileMap;\n}\n\nfunction getPath(filename, fileMap) {\n  let file = fileMap[filename];\n\n  if (!file) return;\n  if (file.__path) return file.__path;\n  if (file.js) return file[\".js\"];\n\n  for (let key in file) {\n    return file[key];\n  }\n}\n\nfunction findAndSetFile(tagDef, tagDirname) {\n  try {\n    if (!taglibFS.curFS.statSync(tagDirname).isDirectory()) {\n      return;\n    }\n  } catch (_) {\n    return;\n  }\n\n  let tagName = nodePath.basename(tagDirname);\n  let fileMap = getFileMap(tagDirname);\n\n  for (let i = 0; i < searchFiles.length; i++) {\n    let name = searchFiles[i].name;\n    let type = searchFiles[i].type;\n    let repeatedName = tagName + \".\" + name.replace(\"index.\", \"\");\n    let path = getPath(name, fileMap) || getPath(repeatedName, fileMap);\n\n    if (path) {\n      tagDef[type] = path;\n      return true;\n    }\n  }\n}\n\nfunction hasFile(tagDef) {\n  for (let i = 0; i < tagFileTypes.length; i++) {\n    if (tagDef[tagFileTypes[i]]) return true;\n  }\n  return false;\n}\n\n/**\n * @param {String} tagsConfigPath path to tag definition file\n * @param {String} tagsConfigDirname path to directory of tags config file (should be path.dirname(tagsConfigPath))\n * @param {String|Object} dir the path to directory to scan\n * @param {String} taglib the taglib that is being loaded\n */\nmodule.exports = function scanTagsDir(\n  tagsConfigPath,\n  tagsConfigDirname,\n  dir,\n  taglib,\n  dependencyChain\n) {\n  let prefix;\n\n  if (typeof dir === \"object\") {\n    prefix = dir.prefix;\n    dir = dir.path;\n  }\n\n  if (prefix == null) {\n    // no prefix by default\n    prefix = \"\";\n  }\n\n  dir = nodePath.resolve(tagsConfigDirname, dir);\n  let children = taglibFS.curFS.readdirSync(dir);\n\n  for (let i = 0, len = children.length; i < len; i++) {\n    let childFilename = children[i];\n    if (childFilename === \"node_modules\") {\n      continue;\n    }\n\n    let tagName;\n    let tagDef = null;\n    let tagDirname;\n    let tagJsonPath;\n\n    let ext = nodePath.extname(childFilename);\n    if (ext === \".marko\") {\n      tagName = childFilename.slice(0, 0 - ext.length);\n      tagDirname = dir;\n      tagDef = createDefaultTagDef();\n      tagDef.template = nodePath.join(dir, childFilename);\n    } else {\n      tagName = prefix + childFilename;\n\n      tagDirname = nodePath.join(dir, childFilename);\n      tagJsonPath = nodePath.join(tagDirname, \"marko-tag.json\");\n\n      let hasTagJson = false;\n      try {\n        taglibFS.curFS.statSync(tagJsonPath);\n        hasTagJson = true;\n        // eslint-disable-next-line no-empty\n      } catch (_) {}\n      if (hasTagJson) {\n        // marko-tag.json exists in the directory, use that as the tag definition\n        tagDef = jsonFileReader.readFileSync(tagJsonPath);\n      } else {\n        tagJsonPath = null;\n        tagDef = createDefaultTagDef();\n      }\n\n      if (!hasFile(tagDef)) {\n        let fileWasSet = findAndSetFile(tagDef, tagDirname);\n        if (!fileWasSet) {\n          if (hasTagJson) {\n            throw new Error(\n              \"Invalid tag file: \" +\n                tagJsonPath +\n                \". Neither a renderer or a template was found for tag. \" +\n                JSON.stringify(tagDef, null, 2)\n            );\n          } else {\n            // Skip this directory... there doesn't appear to be anything in it\n            continue;\n          }\n        }\n      }\n\n      if (!hasTagJson && (tagDef.renderer || tagDef.template)) {\n        let templateCode = String(\n          taglibFS.curFS.readFileSync(\n            tagDef.renderer || tagDef.template,\n            fsReadOptions\n          )\n        );\n        let extractedTagDef = tagDefFromCode.extractTagDef(templateCode);\n        if (extractedTagDef) {\n          extend(tagDef, extractedTagDef);\n        }\n      }\n    }\n\n    let tagDependencyChain;\n\n    if (tagJsonPath) {\n      tagDependencyChain = dependencyChain.append(tagJsonPath);\n    } else {\n      tagDependencyChain = dependencyChain.append(tagDirname);\n    }\n\n    let tag = new types.Tag(tagJsonPath || tagDirname);\n    loaders.loadTagFromProps(tag, tagDef, tagDependencyChain);\n    tag.name = tag.name || tagName;\n    taglib.addTag(tag);\n  }\n};\n"],"file":"scanTagsDir.js"}

package/dist/taglib/loader/tag-def-from-code.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/taglib/loader/tag-def-from-code.js"],"names":["tagStartRegExp","tokensRegExp","extractTagDef","code","startMatches","exec","tagDefStart","tagDefEnd","index","length","nextTokenMatches","lastIndex","depth","jsTagDef","substring","tagDefObject","JSON","parse","e","eval","exports"],"mappings":"cAAA;AACA;AACA,IAAIA,cAAc,GAAG,qDAArB;;AAEA;AACA,IAAIC,YAAY;AACd,yFADF;;AAGA,SAASC,aAAT,CAAuBC,IAAvB,EAA6B;AAC3B,MAAIC,YAAY,GAAGJ,cAAc,CAACK,IAAf,CAAoBF,IAApB,CAAnB;;AAEA,MAAIG,WAAJ;AACA,MAAIC,SAAJ;;AAEA,MAAIH,YAAJ,EAAkB;AAChBE,IAAAA,WAAW,GAAGF,YAAY,CAACI,KAAb,GAAqBJ,YAAY,CAAC,CAAD,CAAZ,CAAgBK,MAAnD;AACA,QAAIC,gBAAJ;AACAT,IAAAA,YAAY,CAACU,SAAb,GAAyBL,WAAzB;AACA,QAAIM,KAAK,GAAG,CAAZ;;AAEA,WAAQF,gBAAgB,GAAGT,YAAY,CAACI,IAAb,CAAkBF,IAAlB,CAA3B,EAAqD;AACnD,UAAIO,gBAAgB,CAAC,CAAD,CAAhB,KAAwB,GAA5B,EAAiC;AAC/BE,QAAAA,KAAK;AACL;AACD,OAHD,MAGO,IAAIF,gBAAgB,CAAC,CAAD,CAAhB,KAAwB,GAA5B,EAAiC;AACtC,YAAI,EAAEE,KAAF,KAAY,CAAhB,EAAmB;AACjBL,UAAAA,SAAS,GAAGN,YAAY,CAACU,SAAzB;AACA;AACD;AACF,OALM,MAKA,IAAID,gBAAgB,CAAC,CAAD,CAAhB,KAAwB,GAA5B,EAAiC;AACtCH,QAAAA,SAAS,GAAGG,gBAAgB,CAACF,KAA7B;AACA;AACD;AACF;;AAED,QAAIF,WAAW,IAAI,IAAf,IAAuBC,SAAS,IAAI,IAAxC,EAA8C;AAC5C,UAAIM,QAAQ,GAAGV,IAAI,CAACW,SAAL,CAAeR,WAAf,EAA4BC,SAA5B,CAAf;AACA,UAAIQ,YAAJ;;AAEA,UAAI;AACF;AACAA,QAAAA,YAAY,GAAGC,IAAI,CAACC,KAAL,CAAWJ,QAAX,CAAf;AACD,OAHD,CAGE,OAAOK,CAAP,EAAU;AACV;AACA,YAAI;AACFH,UAAAA,YAAY,GAAGI,IAAI,CAAC,MAAMN,QAAN,GAAiB,GAAlB,CAAnB;AACD,SAFD,CAEE,OAAOK,CAAP,EAAU;AACVH,UAAAA,YAAY,GAAG,EAAf;AACD;AACF;AACD,aAAOA,YAAP;AACD;AACF,GAtCD,MAsCO;AACL,WAAO,IAAP;AACD;AACF;;AAEDK,OAAO,CAAClB,aAAR,GAAwBA,aAAxB","sourcesContent":["// Rather than using a full-blown JavaScript parser, we are going to use a few regular expressions\n// to tokenize the code and find what we are interested in\nvar tagStartRegExp = /(^\\s*(?:(?:exports.(?:tag|TAG))|(?:TAG))\\s*=\\s*)\\{/m;\n\n// Tokens: \"<string>\", '<string>', /*<some comment*/, //<single line comment>, {, }, ;\nvar tokensRegExp =\n  /\"(?:[^\"]|\\\\\")*\"|'(?:[^'])|(\\/\\*([^*]|[\\r\\n]|(\\*+([^*/]|[\\r\\n])))*\\*+\\/)|(\\/\\/.*)|[{};]/g;\n\nfunction extractTagDef(code) {\n  var startMatches = tagStartRegExp.exec(code);\n\n  var tagDefStart;\n  var tagDefEnd;\n\n  if (startMatches) {\n    tagDefStart = startMatches.index + startMatches[1].length;\n    var nextTokenMatches;\n    tokensRegExp.lastIndex = tagDefStart;\n    var depth = 0;\n\n    while ((nextTokenMatches = tokensRegExp.exec(code))) {\n      if (nextTokenMatches[0] === \"{\") {\n        depth++;\n        continue;\n      } else if (nextTokenMatches[0] === \"}\") {\n        if (--depth === 0) {\n          tagDefEnd = tokensRegExp.lastIndex;\n          break;\n        }\n      } else if (nextTokenMatches[0] === \";\") {\n        tagDefEnd = nextTokenMatches.index;\n        break;\n      }\n    }\n\n    if (tagDefStart != null && tagDefEnd != null) {\n      var jsTagDef = code.substring(tagDefStart, tagDefEnd);\n      var tagDefObject;\n\n      try {\n        // Try parsing it as JSON\n        tagDefObject = JSON.parse(jsTagDef);\n      } catch (e) {\n        // Try parsing it as JavaScript\n        try {\n          tagDefObject = eval(\"(\" + jsTagDef + \")\");\n        } catch (e) {\n          tagDefObject = {};\n        }\n      }\n      return tagDefObject;\n    }\n  } else {\n    return null;\n  }\n}\n\nexports.extractTagDef = extractTagDef;\n"],"file":"tag-def-from-code.js"}

package/dist/taglib/loader/types.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/taglib/loader/types.js"],"names":["exports","Taglib","require","Tag","Attribute","Property","Transformer"],"mappings":"aAAAA,OAAO,CAACC,MAAR,GAAiBC,OAAO,CAAC,UAAD,CAAxB;AACAF,OAAO,CAACG,GAAR,GAAcD,OAAO,CAAC,OAAD,CAArB;AACAF,OAAO,CAACI,SAAR,GAAoBF,OAAO,CAAC,aAAD,CAA3B;AACAF,OAAO,CAACK,QAAR,GAAmBH,OAAO,CAAC,YAAD,CAA1B;AACAF,OAAO,CAACM,WAAR,GAAsBJ,OAAO,CAAC,eAAD,CAA7B","sourcesContent":["exports.Taglib = require(\"./Taglib\");\nexports.Tag = require(\"./Tag\");\nexports.Attribute = require(\"./Attribute\");\nexports.Property = require(\"./Property\");\nexports.Transformer = require(\"./Transformer\");\n"],"file":"types.js"}

package/dist/taglib/lookup/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/taglib/lookup/index.js"],"names":["ok","require","taglibTypes","extend","hasOwnProperty","Object","prototype","TAG_COMPARATOR","a","b","name","localeCompare","merge","target","source","descs","getOwnPropertyDescriptors","key","desc","writable","sourceVal","value","targetVal","Array","isArray","concat","constructor","defineProperty","TaglibLookup","merged","attributeGroups","taglibsById","_sortedTags","undefined","hasTaglib","taglib","call","id","_mergeNestedTags","Tag","handleNestedTags","tag","parentTagName","nestedTags","nestedTag","fullyQualifiedName","clonedNestedTag","tags","addTaglib","attributes","patternAttributes","getTagsSorted","sortedTags","tagName","push","sort","forEachAttribute","callback","globalAttributes","taglibAttributeGroups","findAttributesForTagName","handleAttr","attrDef","ref","attrName","i","length","attributeGroupName","attributeGroup","forEach","getTag","element","getAttribute","attr","findAttributeForTag","attribute","len","patternAttribute","pattern","test","tryAttribute","toString","keys","join","module","exports"],"mappings":"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","sourcesContent":["\"use strict\";\n\nvar ok = require(\"assert\").ok;\nvar taglibTypes = require(\"../loader/types\");\nvar extend = require(\"raptor-util/extend\");\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nfunction TAG_COMPARATOR(a, b) {\n  return a.name.localeCompare(b.name);\n}\n\nfunction merge(target, source) {\n  const descs = Object.getOwnPropertyDescriptors(source);\n  for (const key in descs) {\n    const desc = descs[key];\n    if (desc.writable) {\n      const sourceVal = desc.value;\n      const targetVal = target[key];\n\n      if (\n        sourceVal &&\n        typeof sourceVal === \"object\" &&\n        targetVal &&\n        typeof targetVal === \"object\"\n      ) {\n        target[key] = Array.isArray(targetVal)\n          ? targetVal.concat(sourceVal)\n          : Array.isArray(sourceVal)\n          ? [targetVal].concat(sourceVal)\n          : merge(merge(new targetVal.constructor(), targetVal), sourceVal);\n        continue;\n      }\n    }\n\n    Object.defineProperty(target, key, desc);\n  }\n\n  return target;\n}\n\n/**\n * A taglib lookup merges in multiple taglibs so there is a single and fast lookup\n * for custom tags and custom attributes.\n */\nclass TaglibLookup {\n  constructor() {\n    this.merged = {\n      attributeGroups: {}\n    };\n    this.taglibsById = {};\n\n    this._sortedTags = undefined;\n  }\n\n  hasTaglib(taglib) {\n    return hasOwnProperty.call(this.taglibsById, taglib.id);\n  }\n\n  _mergeNestedTags(taglib) {\n    var Tag = taglibTypes.Tag;\n    // Loop over all of the nested tags and register a new custom tag\n    // with the fully qualified name\n\n    var merged = this.merged;\n\n    function handleNestedTags(tag, parentTagName) {\n      for (const key in tag.nestedTags) {\n        const nestedTag = tag.nestedTags[key];\n\n        var fullyQualifiedName = parentTagName + \":\" + nestedTag.name;\n        // Create a clone of the nested tag since we need to add some new\n        // properties\n        var clonedNestedTag = new Tag();\n        extend(clonedNestedTag, nestedTag);\n        // Record the fully qualified name of the parent tag that this\n        // custom tag is associated with.\n        clonedNestedTag.parentTagName = parentTagName;\n        clonedNestedTag.name = fullyQualifiedName;\n        merged.tags[fullyQualifiedName] = clonedNestedTag;\n        handleNestedTags(clonedNestedTag, fullyQualifiedName);\n      }\n    }\n\n    for (const key in taglib.tags) {\n      const tag = taglib.tags[key];\n      handleNestedTags(tag, tag.name);\n    }\n  }\n\n  addTaglib(taglib) {\n    ok(taglib, '\"taglib\" is required');\n    ok(taglib.id, '\"taglib.id\" expected');\n\n    if (hasOwnProperty.call(this.taglibsById, taglib.id)) {\n      return;\n    }\n\n    // console.log(\"TAGLIB:\", taglib);\n\n    this._sortedTags = undefined;\n\n    this.taglibsById[taglib.id] = taglib;\n\n    merge(this.merged, {\n      tags: taglib.tags,\n      attributes: taglib.attributes,\n      patternAttributes: taglib.patternAttributes,\n      attributeGroups: taglib.attributeGroups || {}\n    });\n\n    this._mergeNestedTags(taglib);\n  }\n\n  getTagsSorted() {\n    var sortedTags = this._sortedTags;\n\n    if (sortedTags === undefined) {\n      sortedTags = this._sortedTags = [];\n      var tags = this.merged.tags;\n      for (var tagName in tags) {\n        sortedTags.push(tags[tagName]);\n      }\n      sortedTags.sort(TAG_COMPARATOR);\n    }\n\n    return sortedTags;\n  }\n\n  forEachAttribute(tagName, callback) {\n    var tags = this.merged.tags;\n    if (!tags) {\n      return;\n    }\n\n    var globalAttributes = this.merged.attributes;\n    var taglibAttributeGroups = this.merged.attributeGroups;\n\n    function findAttributesForTagName(tagName) {\n      var tag = tags[tagName];\n      if (!tag) {\n        return;\n      }\n\n      function handleAttr(attrDef) {\n        if (attrDef.ref) {\n          attrDef = globalAttributes[attrDef.ref];\n        }\n        callback(attrDef, tag);\n      }\n\n      var attributes = tag.attributes;\n      if (!attributes) {\n        return;\n      }\n\n      for (var attrName in attributes) {\n        if (hasOwnProperty.call(attributes, attrName)) {\n          handleAttr(attributes[attrName], tag);\n        }\n      }\n\n      if (tag.attributeGroups) {\n        for (let i = 0; i < tag.attributeGroups.length; i++) {\n          let attributeGroupName = tag.attributeGroups[i];\n          let attributeGroup = taglibAttributeGroups[attributeGroupName];\n          if (attributeGroup) {\n            for (let attrName in attributeGroup) {\n              handleAttr(attributeGroup[attrName]);\n            }\n          }\n        }\n      }\n\n      if (tag.patternAttributes) {\n        tag.patternAttributes.forEach(handleAttr);\n      }\n    }\n\n    findAttributesForTagName(tagName); // Look for an exact match at the tag level\n    findAttributesForTagName(\"*\"); // Including attributes that apply to all tags\n  }\n\n  getTag(element) {\n    var tags = this.merged.tags;\n    if (!tags) {\n      return;\n    }\n\n    return tags[element.tagName || element];\n  }\n\n  getAttribute(element, attr) {\n    if (typeof element === \"string\") {\n      element = {\n        tagName: element\n      };\n    }\n\n    if (typeof attr === \"string\") {\n      attr = {\n        name: attr\n      };\n    }\n\n    var tags = this.merged.tags;\n    if (!tags) {\n      return;\n    }\n\n    var taglibAttributeGroups = this.merged.attributeGroups;\n\n    var tagName = element.tagName;\n    var attrName = attr.name;\n\n    function findAttributeForTag(tag, attributes, attrName) {\n      // try by exact match first\n      var attribute = attributes[attrName];\n      if (attribute === undefined) {\n        if (tag.attributeGroups) {\n          for (let i = 0; i < tag.attributeGroups.length; i++) {\n            let attributeGroupName = tag.attributeGroups[i];\n            let attributeGroup = taglibAttributeGroups[attributeGroupName];\n            if (attributeGroup) {\n              attribute = attributeGroup[attrName];\n              if (attribute !== undefined) {\n                break;\n              }\n            }\n          }\n        }\n      }\n\n      if (attribute === undefined && attrName !== \"*\") {\n        if (tag.patternAttributes) {\n          // try searching by pattern\n          for (var i = 0, len = tag.patternAttributes.length; i < len; i++) {\n            var patternAttribute = tag.patternAttributes[i];\n            if (patternAttribute.pattern.test(attrName)) {\n              attribute = patternAttribute;\n              break;\n            }\n          }\n        }\n      }\n\n      return attribute;\n    }\n\n    var globalAttributes = this.merged.attributes;\n\n    function tryAttribute(tagName, attrName) {\n      var tag = tags[tagName];\n      if (!tag) {\n        return undefined;\n      }\n\n      return findAttributeForTag(tag, tag.attributes, attrName);\n    }\n\n    var attrDef =\n      tryAttribute(tagName, attrName) || // Look for an exact match at the tag level\n      tryAttribute(\"*\", attrName) || // If not there, see if there is a exact match on the attribute name for attributes that apply to all tags\n      tryAttribute(tagName, \"*\"); // Otherwise, see if there is a splat attribute for the tag\n\n    if (attrDef && attrDef.ref) {\n      attrDef = globalAttributes[attrDef.ref];\n    }\n\n    return attrDef;\n  }\n\n  toString() {\n    return \"lookup: \" + Object.keys(this.taglibsById).join(\", \");\n  }\n}\n\nmodule.exports = TaglibLookup;\n"],"file":"index.js"}