>(type: T, n: Node | null | undefined, required: Partial): n is P`,\n\n `export function is
(type: string, n: Node | null | undefined, required: Partial
): n is P`,\n `export function is(type: string, n: Node | null | undefined, required?: Partial): n is Node`,\n `export function isBinding(node: Node, parent: Node, grandparent?: Node): boolean`,\n\n `export function isBlockScoped(node: Node): node is FunctionDeclaration | ClassDeclaration | VariableDeclaration`,\n `export function isImmutable(node: Node): node is Immutable`,\n `export function isLet(node: Node): node is VariableDeclaration`,\n `export function isNode(node: object | null | undefined): node is Node`,\n `export function isNodesEquivalent>(a: T, b: any): b is T`,\n `export function isNodesEquivalent(a: any, b: any): boolean`,\n `export function isPlaceholderType(placeholderType: Node['type'], targetType: Node['type']): boolean`,\n `export function isReferenced(node: Node, parent: Node, grandparent?: Node): boolean`,\n `export function isScope(node: Node, parent: Node): node is Scopable`,\n `export function isSpecifierDefault(specifier: ModuleSpecifier): boolean`,\n `export function isType(nodetype: string, targetType: T): nodetype is T`,\n `export function isType(nodetype: string | null | undefined, targetType: string): boolean`,\n `export function isValidES3Identifier(name: string): boolean`,\n `export function isValidIdentifier(name: string): boolean`,\n `export function isVar(node: Node): node is VariableDeclaration`,\n // the MemberExpression implication is incidental, but it follows from the implementation\n\n `export function matchesPattern(node: Node | null | undefined, match: string | ReadonlyArray, allowPartial?: boolean): node is MemberExpression`,\n\n `export function validate(n: Node | null | undefined, key: K, value: T[K]): void;`,\n `export function validate(n: Node, key: string, value: any): void;`,\n);\n\nfor (const type in t.DEPRECATED_KEYS) {\n code += `/**\n * @deprecated Use \\`${t.DEPRECATED_KEYS[type]}\\`\n */\nexport type ${type} = ${t.DEPRECATED_KEYS[type]};\\n\n`;\n}\n\nfor (const type in t.FLIPPED_ALIAS_KEYS) {\n const types = t.FLIPPED_ALIAS_KEYS[type];\n code += `export type ${type} = ${types\n .map((type) => `${type}`)\n .join(\" | \")};\\n`;\n}\ncode += \"\\n\";\n\ncode += \"export interface Aliases {\\n\";\nfor (const type in t.FLIPPED_ALIAS_KEYS) {\n code += ` ${type}: ${type};\\n`;\n}\ncode += \"}\\n\\n\";\n\ncode += lines.join(\"\\n\") + \"\\n\";\n\n//\n\nexport default code;\n\n//\n\nfunction areAllRemainingFieldsNullable(fieldName, fieldNames, fields) {\n const index = fieldNames.indexOf(fieldName);\n return fieldNames.slice(index).every((_) => isNullable(fields[_]));\n}\n\nfunction hasDefault(field) {\n return field.default != null;\n}\n\nfunction isNullable(field) {\n return field.optional || hasDefault(field);\n}\n\nfunction sortFieldNames(fields, type) {\n return fields.sort((fieldA, fieldB) => {\n const indexA = t.BUILDER_KEYS[type].indexOf(fieldA);\n const indexB = t.BUILDER_KEYS[type].indexOf(fieldB);\n if (indexA === indexB) return fieldA < fieldB ? -1 : 1;\n if (indexA === -1) return 1;\n if (indexB === -1) return -1;\n return indexA - indexB;\n });\n}\n\nfunction stringifyValidator(validator, nodePrefix) {\n if (validator === undefined) {\n return \"any\";\n }\n\n if (validator.each) {\n return `Array<${stringifyValidator(validator.each, nodePrefix)}>`;\n }\n\n if (validator.chainOf) {\n const ret = stringifyValidator(validator.chainOf[1], nodePrefix);\n return Array.isArray(ret) && ret.length === 1 && ret[0] === \"any\"\n ? stringifyValidator(validator.chainOf[0], nodePrefix)\n : ret;\n }\n\n if (validator.oneOf) {\n return validator.oneOf.map(JSON.stringify).join(\" | \");\n }\n\n if (validator.oneOfNodeTypes) {\n return validator.oneOfNodeTypes.map((_) => nodePrefix + _).join(\" | \");\n }\n\n if (validator.oneOfNodeOrValueTypes) {\n return validator.oneOfNodeOrValueTypes\n .map((_) => {\n return isValueType(_) ? _ : nodePrefix + _;\n })\n .join(\" | \");\n }\n\n if (validator.type) {\n return validator.type;\n }\n\n if (validator.shapeOf) {\n return (\n \"{ \" +\n Object.keys(validator.shapeOf)\n .map((shapeKey) => {\n const propertyDefinition = validator.shapeOf[shapeKey];\n if (propertyDefinition.validate) {\n const isOptional =\n propertyDefinition.optional || propertyDefinition.default != null;\n return (\n shapeKey +\n (isOptional ? \"?: \" : \": \") +\n stringifyValidator(propertyDefinition.validate)\n );\n }\n return null;\n })\n .filter(Boolean)\n .join(\", \") +\n \" }\"\n );\n }\n\n return [\"any\"];\n}\n\nfunction isValueType(type) {\n return type.charAt(0).toLowerCase() === type.charAt(0);\n}\n\nfunction toFunctionName(typeName) {\n const _ = typeName.replace(/^TS/, \"ts\").replace(/^JSX/, \"jsx\");\n return _.slice(0, 1).toLowerCase() + _.slice(1);\n}\n"
},
{
"path": "packages/compiler/scripts/types.js",
"content": "import fs from \"fs\";\n\nimport babelTraverseCode from \"./types/babel-traverse\";\nimport babelTypesCode from \"./types/babel-types\";\n\nfs.mkdirSync(\"dist\", { recursive: true });\nfs.writeFileSync(\"dist/types.d.ts\", babelTypesCode);\nfs.writeFileSync(\"dist/traverse.d.ts\", babelTraverseCode);\n"
},
{
"path": "packages/compiler/src/babel-plugin/file.js",
"content": "import { File } from \"@marko/compiler/internal/babel\";\n\nimport { buildCodeFrameError } from \"../util/build-code-frame\";\n\nexport class MarkoFile extends File {\n addHelper() {\n throw new Error(\"addHelper is not supported during a Marko transform\");\n }\n\n buildCodeFrameError(node, msg) {\n return buildCodeFrameError(this.opts.filename, this.code, node.loc, msg);\n }\n}\n"
},
{
"path": "packages/compiler/src/babel-plugin/index.js",
"content": "import {\n pluginTransformTypeScript,\n traverse,\n types as t,\n} from \"@marko/compiler/internal/babel\";\nimport path from \"path\";\n\nimport { diagnosticError } from \"../babel-utils/diagnostics\";\nimport { getFileInternal, setFileInternal } from \"../babel-utils/get-file\";\nimport { getTemplateId } from \"../babel-utils/tags\";\nimport { buildLookup } from \"../taglib\";\nimport taglibConfig from \"../taglib/config\";\nimport { buildCodeFrameError } from \"../util/build-code-frame\";\nimport throwAggregateError from \"../util/merge-errors\";\nimport { Hash } from \"../util/quick-hash\";\nimport shouldOptimize from \"../util/should-optimize\";\nimport tryLoadTranslator from \"../util/try-load-translator\";\nimport { MarkoFile } from \"./file\";\nimport { parseMarko } from \"./parser\";\nimport { visitor as migrate } from \"./plugins/migrate\";\nimport { visitor as transform } from \"./plugins/transform\";\n\nconst SOURCE_FILES = new WeakMap();\nlet stripTypesVisitor;\n\nexport default (api, markoOpts) => {\n api.assertVersion(7);\n const translator = (markoOpts.translator = tryLoadTranslator(\n markoOpts.translator,\n ));\n markoOpts.output = markoOpts.output || \"html\";\n\n if (markoOpts.optimize === undefined) {\n api.cache.using(shouldOptimize);\n markoOpts.optimize = shouldOptimize();\n }\n\n if (!translator || !translator.translate) {\n throw new Error(\n \"@marko/compiler: translator must provide a translate visitor object\",\n );\n }\n\n if (\n markoOpts.output === \"hydrate\" &&\n typeof markoOpts.resolveVirtualDependency !== \"function\"\n ) {\n throw new Error(\n `@marko/compiler: the \"resolveVirtualDependency\" option must be supplied when output is \"hydrate\".`,\n );\n }\n\n if (markoOpts.stripTypes) {\n stripTypesVisitor ||= pluginTransformTypeScript(api, {\n isTSX: false,\n allowNamespaces: true,\n allowDeclareFields: true,\n optimizeConstEnums: true,\n onlyRemoveTypeImports: true,\n disallowAmbiguousJSXLike: false,\n }).visitor;\n }\n\n let curOpts;\n\n return {\n name: \"marko\",\n manipulateOptions(opts) {\n const { parserOpts } = opts;\n // We need to allow these for now since we are not parsing the entire file\n // These types of syntax errors will be picked up by the bundler / runtime anyways.\n parserOpts.allowAwaitOutsideFunction =\n parserOpts.allowImportExportEverywhere =\n parserOpts.allowReturnOutsideFunction =\n parserOpts.allowSuperOutsideMethod =\n parserOpts.allowUndeclaredExports =\n parserOpts.allowNewTargetOutsideFunction =\n parserOpts.createImportExpressions =\n true;\n\n parserOpts.plugins.push(\"objectRestSpread\", \"classProperties\", [\n \"typescript\",\n {\n disallowAmbiguousJSXLike: false,\n dts: false,\n },\n ]);\n curOpts = opts;\n },\n parserOverride(code) {\n const file = getMarkoFile(code, curOpts, markoOpts);\n const finalAst = t.cloneNode(file.ast, true);\n SOURCE_FILES.set(finalAst, file);\n return finalAst;\n },\n pre(file) {\n const { buildError: prevBuildError } = file.hub;\n const { buildCodeFrameError: prevCodeFrameError } = file;\n const prevFS = taglibConfig.fs;\n const prevFile = getFileInternal();\n taglibConfig.fs = markoOpts.fileSystem;\n setFileInternal(file);\n curOpts = undefined;\n try {\n const { ast, metadata } = file;\n const sourceFile = SOURCE_FILES.get(ast);\n metadata.marko = shallowClone(sourceFile.metadata.marko);\n\n if (isMarkoOutput(markoOpts.output)) {\n finalizeMeta(metadata.marko);\n return;\n }\n\n const taglibLookup = sourceFile.___taglibLookup;\n const rootTranslators = [];\n file.buildCodeFrameError = MarkoFile.prototype.buildCodeFrameError;\n file.hub.buildError = file.buildCodeFrameError.bind(file);\n file.markoOpts = markoOpts;\n file.___taglibLookup = taglibLookup;\n file.___getMarkoFile = getMarkoFile;\n\n if (markoOpts.output !== \"hydrate\") {\n for (const id in taglibLookup.taglibsById) {\n addPlugin(\n metadata.marko,\n rootTranslators,\n taglibLookup.taglibsById[id].translator,\n );\n }\n }\n\n rootTranslators.push(translator.translate);\n file.___compileStage = \"translate\";\n traverseAll(file, rootTranslators);\n\n finalizeMeta(metadata.marko);\n file.path.scope.crawl(); // Ensure all scopes are accurate for subsequent babel plugins\n } finally {\n taglibConfig.fs = prevFS;\n setFileInternal(prevFile);\n file.buildCodeFrameError = prevCodeFrameError;\n file.hub.buildError = prevBuildError;\n file.markoOpts =\n file.___taglibLookup =\n file.___getMarkoFile =\n undefined;\n }\n },\n };\n};\n\nfunction getMarkoFile(code, fileOpts, markoOpts) {\n const { translator } = markoOpts;\n let compileCache = markoOpts.cache.get(translator);\n\n if (!compileCache) {\n markoOpts.cache.set(translator, (compileCache = new Map()));\n }\n\n const { filename } = fileOpts;\n const isSource = markoOpts.output === \"source\";\n const isMigrate = markoOpts.output === \"migrate\";\n const canCache = !(isSource || isMigrate);\n const id = getTemplateId(markoOpts, filename);\n const contentHash = canCache && new Hash().update(code).digest();\n let cached = canCache && compileCache.get(id);\n\n if (cached) {\n if (cached.contentHash !== contentHash) {\n // File content changed, invalidate the cache.\n cached = undefined;\n } else {\n for (const watchFile of cached.file.metadata.marko.watchFiles) {\n let mtime = Infinity;\n try {\n mtime = markoOpts.fileSystem.statSync(watchFile).mtime;\n } catch {\n // ignore\n }\n\n if (mtime > cached.time) {\n // Some dependency changed, invalidate the cache.\n cached = undefined;\n break;\n }\n }\n }\n }\n\n if (cached) {\n cached.file.markoOpts = markoOpts;\n return cached.file;\n }\n\n const prevFs = taglibConfig.fs;\n const prevFile = getFileInternal();\n taglibConfig.fs = markoOpts.fileSystem;\n\n try {\n const file = setFileInternal(\n new MarkoFile(fileOpts, {\n code,\n ast: {\n type: \"File\",\n program: {\n type: \"Program\",\n sourceType: \"module\",\n body: [],\n directives: [],\n params: [t.identifier(\"input\")],\n },\n },\n }),\n );\n file.markoOpts = markoOpts;\n file.___compileStage = \"parse\";\n file.___getMarkoFile = getMarkoFile;\n const taglibLookup = (file.___taglibLookup = buildLookup(\n path.dirname(filename),\n translator,\n ));\n const meta = (file.metadata.marko = {\n id,\n deps: [],\n tags: [],\n watchFiles: [],\n diagnostics: [],\n api: translator.preferAPI,\n });\n\n parseMarko(file);\n file.path.scope.crawl(); // Initialize bindings.\n\n if (isSource) {\n if (markoOpts.stripTypes) {\n stripTypes(file);\n }\n return file;\n }\n\n const rootMigrators = [];\n for (const id in taglibLookup.taglibsById) {\n for (const migrator of taglibLookup.taglibsById[id].migrators) {\n addPlugin(meta, rootMigrators, migrator);\n }\n }\n\n rootMigrators.push(migrate);\n file.___compileStage = \"migrate\";\n traverseAll(file, rootMigrators);\n\n if (file.___hasParseErrors) {\n if (markoOpts.errorRecovery) {\n t.traverseFast(file.path.node, (node) => {\n if (node.type === \"MarkoParseError\") {\n diagnosticError(file.path, {\n label: node.label,\n loc: node.errorLoc || node.loc,\n });\n }\n });\n } else {\n let errors = [];\n t.traverseFast(file.path.node, (node) => {\n if (node.type === \"MarkoParseError\") {\n errors.push(\n buildCodeFrameError(\n file.opts.filename,\n file.code,\n node.errorLoc || node.loc,\n node.label,\n ),\n );\n }\n });\n\n throwAggregateError(errors);\n }\n }\n\n if (markoOpts.stripTypes) {\n stripTypes(file);\n }\n\n if (isMigrate) {\n return file;\n }\n\n file.___compileStage = \"transform\";\n\n const rootTransformers = [];\n for (const id in taglibLookup.taglibsById) {\n for (const transformer of taglibLookup.taglibsById[id].transformers) {\n addPlugin(meta, rootTransformers, transformer);\n }\n }\n\n rootTransformers.push(transform);\n if (translator.transform) {\n rootTransformers.push(translator.transform);\n }\n traverseAll(file, rootTransformers);\n file.path.scope.crawl();\n\n for (const taglibId in taglibLookup.taglibsById) {\n const { filePath } = taglibLookup.taglibsById[taglibId];\n\n if (\n filePath[filePath.length - 5] === \".\" &&\n filePath.endsWith(\"marko.json\")\n ) {\n meta.watchFiles.push(filePath);\n }\n }\n\n compileCache.set(id, {\n time: Date.now(),\n file,\n contentHash,\n });\n\n if (translator.analyze) {\n try {\n file.___compileStage = \"analyze\";\n traverseAll(file, translator.analyze);\n } catch (e) {\n compileCache.delete(id);\n throw e;\n }\n }\n\n return file;\n } finally {\n taglibConfig.fs = prevFs;\n setFileInternal(prevFile);\n }\n}\n\nfunction shallowClone(data) {\n const clone = {};\n\n for (const key in data) {\n const v = data[key];\n\n if (v !== undefined) {\n if (v === null || typeof v !== \"object\") {\n clone[key] = v;\n } else {\n const Ctor = v.constructor;\n\n switch (Ctor) {\n case Array:\n clone[key] = [...v];\n break;\n case Object:\n case null:\n clone[key] = { ...v };\n break;\n case Map:\n case Set:\n case Date:\n case RegExp:\n clone[key] = new Ctor(v);\n break;\n\n default:\n throw new Error(`Unsupported metadata type of ${Ctor.name}`);\n }\n }\n }\n }\n\n return clone;\n}\n\nfunction mergeVisitors(all) {\n if (Array.isArray(all)) {\n if (all.length === 1) {\n all = all[0];\n } else {\n return traverse.visitors.merge(all.map(toExploded));\n }\n }\n\n return toExploded(all);\n}\n\nconst explodeCache = new WeakMap();\nfunction toExploded(visitor) {\n let cached = explodeCache.get(visitor);\n if (!cached) {\n cached = traverse.visitors.explode(cloneVisitor(visitor));\n explodeCache.set(visitor, cached);\n }\n\n return cached;\n}\n\nfunction cloneVisitor(visitor) {\n const clone = {};\n for (const key in visitor) {\n clone[key] = cloneVisit(visitor[key]);\n }\n\n return clone;\n}\n\nfunction cloneVisit(visit) {\n if (!visit || typeof visit !== \"object\") {\n return visit;\n }\n\n return { ...visit };\n}\n\nfunction traverseAll(file, visitors) {\n const program = file.path;\n traverse(\n program.node,\n mergeVisitors(visitors),\n program.scope,\n (program.state = { file }),\n program,\n true,\n );\n}\n\nfunction addPlugin(meta, arr, plugin) {\n if (plugin) {\n const hook = plugin.hook.default || plugin.hook;\n\n if (plugin.path) {\n meta.watchFiles.push(plugin.path);\n }\n\n if (Array.isArray(hook)) {\n arr.push(...hook);\n } else {\n arr.push(hook);\n }\n }\n}\n\nfunction stripTypes(file) {\n const importScriptlets = new Map();\n for (const path of file.path.get(\"body\")) {\n if (path.type === \"MarkoScriptlet\" && path.node.static) {\n for (const stmt of path.get(\"body\")) {\n if (stmt.isImportDeclaration()) {\n // Hoist import declarations from scriptlets\n // temporarily so that they will be processed by\n // babel typescript transform.\n const importNode = stmt.node;\n importScriptlets.set(importNode, path.node);\n stmt.remove();\n path.insertBefore(importNode);\n }\n }\n }\n }\n\n traverseAll(file, stripTypesVisitor);\n\n for (const path of file.path.get(\"body\")) {\n if (path.type === \"ExportNamedDeclaration\") {\n if (!(path.node.declaration || path.node.specifiers.length)) {\n // The babel typescript plugin will add an empty export declaration\n // if there are no other imports/exports in the file.\n // This is not needed for Marko file outputs since there is always\n // a default export.\n path.remove();\n }\n } else if (path.isImportDeclaration()) {\n const importNode = path.node;\n const scriptlet = importScriptlets.get(importNode);\n if (scriptlet) {\n let hasTypes = false;\n for (const specifier of path.get(\"specifiers\")) {\n if (\n specifier.node.type === \"ImportSpecifier\" &&\n specifier.node.importKind === \"type\"\n ) {\n hasTypes = true;\n specifier.remove();\n }\n }\n\n path.remove();\n\n // Add back imports from scriptlets that were\n // hoisted for the babel typescript transform.\n if (!hasTypes || importNode.specifiers.length) {\n scriptlet.body.unshift(importNode);\n }\n }\n }\n }\n}\n\nfunction isMarkoOutput(output) {\n return output === \"source\" || output === \"migrate\";\n}\n\nfunction finalizeMeta(meta) {\n meta.watchFiles = [...new Set(meta.watchFiles)];\n if (meta.analyzedTags) {\n meta.analyzedTags = [...meta.analyzedTags];\n }\n}\n"
},
{
"path": "packages/compiler/src/babel-plugin/parser.js",
"content": "import {\n getTagDefForTagName,\n parseArgs,\n parseExpression,\n parseParams,\n parseStatements,\n parseTemplateLiteral,\n parseTypeArgs,\n parseTypeParams,\n parseVar,\n} from \"@marko/compiler/babel-utils\";\nimport { types as t } from \"@marko/compiler/internal/babel\";\nimport { createParser, TagType } from \"htmljs-parser\";\n\nimport { buildCodeFrameError } from \"../util/build-code-frame\";\nimport throwAggregateError from \"../util/merge-errors\";\n\nconst noop = () => {};\nconst emptyRange = (part) => part.start === part.end;\nconst isAttrTag = (tag) => tag.name.value?.[0] === \"@\";\nconst isStatementTag = (tag) => tag.tagDef?.parseOptions?.statement;\nconst toBabelPosition = ({ line, character }) => ({\n // Babel lines start at 1 and use \"column\" instead of \"character\".\n line: line + 1,\n column: character,\n});\n\nexport function parseMarko(file) {\n const { code } = file;\n const { htmlParseOptions = {} } = file.markoOpts;\n const { watchFiles } = file.metadata.marko;\n const parseVisits = [];\n let currentTag = file.path;\n let currentBody = currentTag;\n let currentAttr = undefined;\n let currentShorthandId = undefined;\n let currentShorthandClassNames = undefined;\n let { preserveWhitespace } = htmlParseOptions;\n let preservingWhitespaceUntil = preserveWhitespace;\n let onNext = noop;\n const positionAt = (index) => toBabelPosition(parser.positionAt(index));\n const locationAt = (range) => {\n const { start, end } = parser.locationAt(range);\n return {\n start: toBabelPosition(start),\n end: toBabelPosition(end),\n };\n };\n const withLoc = (node, range) => {\n node.start = range.start;\n node.end = range.end;\n node.loc = locationAt(range);\n return node;\n };\n const enterTag = (node) => {\n if (isAttrTag(node)) {\n if (currentTag === file.path) {\n throw file.buildCodeFrameError(\n node.name,\n \"@tags must be nested within another element.\",\n );\n }\n\n let previousSiblingIndex = currentBody.length;\n while (previousSiblingIndex) {\n let previousSibling = currentBody[--previousSiblingIndex];\n if (!t.isMarkoComment(previousSibling)) {\n break;\n }\n currentTag.pushContainer(\"attributeTags\", previousSibling.node);\n currentBody.get(\"body\").get(previousSiblingIndex).remove();\n }\n\n currentTag = currentTag.pushContainer(\"attributeTags\", node)[0];\n } else {\n currentTag = currentBody.pushContainer(\"body\", node)[0];\n }\n currentBody = currentTag.get(\"body\");\n onNext(node);\n };\n const pushContent = (node) => {\n currentBody.node.body.push(node);\n onNext(node);\n };\n const endAttr = () => {\n if (currentAttr) {\n currentAttr.loc = locationAt(currentAttr);\n currentAttr = undefined;\n }\n };\n const parseTemplateString = ({ quasis, expressions }) => {\n switch (expressions.length) {\n case 0: {\n const [first] = quasis;\n return withLoc(t.stringLiteral(parser.read(first)), first);\n }\n case 1: {\n if (emptyRange(quasis[0]) && emptyRange(quasis[1])) {\n const [{ value }] = expressions;\n const result = parseExpression(\n file,\n parser.read(value),\n value.start,\n value.end,\n );\n if (t.isStringLiteral(result)) {\n // convert to template literal just so that we don't mistake it for a native tag if this is a tag name.\n return withLoc(\n t.templateLiteral([templateElement(result.value, true)], []),\n value,\n );\n } else {\n return result;\n }\n }\n }\n }\n\n const [{ start }] = quasis;\n const end = quasis[quasis.length - 1].end;\n return parseTemplateLiteral(file, parser.read({ start, end }), start, end);\n };\n\n const parser = createParser({\n onError(part) {\n const err = buildCodeFrameError(\n file.opts.filename,\n file.code,\n locationAt(part),\n part.message,\n );\n\n if (!file.___hasParseErrors) {\n throw err;\n }\n\n const errors = [];\n t.traverseFast(file.path.node, (node) => {\n if (node.type === \"MarkoParseError\") {\n errors.push(\n buildCodeFrameError(\n file.opts.filename,\n file.code,\n node.errorLoc || node.loc,\n node.label,\n ),\n );\n }\n });\n\n errors.push(err);\n throwAggregateError(errors);\n },\n onText(part) {\n const rawValue = parser.read(part);\n\n if (preservingWhitespaceUntil) {\n pushContent(withLoc(t.markoText(rawValue), part));\n return;\n }\n\n if (/^(?:[\\n\\r]\\s*)?(?:[\\n\\r]\\s*)?$/.test(rawValue)) return;\n\n const { body } = currentBody.node;\n let prev;\n let prevIndex = body.length;\n // Find previous non-scriptlet or comment.\n while (prevIndex > 0) {\n prev = body[--prevIndex];\n\n if (t.isMarkoScriptlet(prev) || t.isMarkoComment(prev)) {\n prev = undefined;\n } else {\n break;\n }\n }\n\n let value = rawValue;\n switch (prev?.type) {\n case \"MarkoPlaceholder\":\n break;\n case \"MarkoText\":\n if (/\\s$/.test(prev.value)) {\n value = value.replace(/^\\s+/, \"\");\n }\n break;\n case \"MarkoTag\":\n if (isStatementTag(prev) || isAttrTag(prev)) {\n value = value.replace(/^[\\n\\r]\\s*/, \"\");\n }\n break;\n default:\n value = value.replace(/^[\\n\\r]\\s*/, \"\");\n break;\n }\n\n if (!value) return;\n\n const node = t.markoText(value);\n pushContent(node);\n onNext = (next) => {\n switch (next?.type) {\n case \"MarkoScriptlet\":\n case \"MarkoComment\":\n return;\n case \"MarkoPlaceholder\":\n break;\n case \"MarkoText\":\n if (/^\\s/.test(next.value)) {\n value = value.replace(/\\s+$/, \"\");\n }\n break;\n case \"MarkoTag\":\n if (isStatementTag(next) || isAttrTag(next)) {\n value = value.replace(/[\\n\\r]\\s*$/, \"\");\n }\n\n break;\n default:\n value = value.replace(/[\\n\\r]\\s*$/, \"\");\n break;\n }\n\n node.value = value.replace(/\\s+/g, \" \");\n\n if (node.value) {\n const trimmedStart = part.start + rawValue.indexOf(value);\n withLoc(node, {\n start: trimmedStart,\n end: trimmedStart + rawValue.length,\n });\n } else {\n body.splice(body.indexOf(node), 1);\n }\n\n onNext = noop;\n };\n },\n onCDATA(part) {\n pushContent(withLoc(t.markoCDATA(parser.read(part.value)), part));\n },\n onDoctype(part) {\n pushContent(withLoc(t.markoDocumentType(parser.read(part.value)), part));\n },\n onDeclaration(part) {\n pushContent(withLoc(t.markoDeclaration(parser.read(part.value)), part));\n },\n onComment(part) {\n pushContent(withLoc(t.markoComment(parser.read(part.value)), part));\n },\n onTagTypeArgs(part) {\n currentTag.node.typeArguments = parseTypeArgs(\n file,\n parser.read(part.value),\n part.value.start,\n part.value.end,\n );\n },\n onTagTypeParams(part) {\n currentBody.node.typeParameters = parseTypeParams(\n file,\n parser.read(part.value),\n part.value.start,\n part.value.end,\n );\n },\n onPlaceholder(part) {\n pushContent(\n withLoc(\n t.markoPlaceholder(\n parseExpression(\n file,\n parser.read(part.value),\n part.value.start,\n part.value.end,\n ),\n part.escape,\n ),\n part,\n ),\n );\n },\n onScriptlet(part) {\n pushContent(\n withLoc(\n t.markoScriptlet(\n parseStatements(\n file,\n parser.read(part.value),\n part.value.start,\n part.value.end,\n ),\n ),\n part,\n ),\n );\n },\n onOpenTagName(part) {\n const tagName = parseTemplateString(part);\n const node = t.markoTag(tagName, [], t.markoTagBody());\n let parseType = TagType.html;\n node.start =\n part.start - (part.start && code[part.start - 1] === \"<\" ? 1 : 0); // Account for leading `<` in html mode.\n node.end = part.end;\n\n if (t.isStringLiteral(tagName)) {\n const literalTagName = tagName.value || (tagName.value = \"div\");\n\n if (literalTagName === \"%\") {\n throw file.buildCodeFrameError(\n tagName,\n \"<% scriptlets %> are no longer supported.\",\n );\n }\n\n const parseOptions = (node.tagDef = getTagDefForTagName(\n file,\n literalTagName,\n ))?.parseOptions;\n\n if (parseOptions) {\n if (parseOptions.preserveWhitespace) {\n preservingWhitespaceUntil = node;\n }\n\n if (parseOptions.statement) {\n parseType = TagType.statement;\n } else if (parseOptions.openTagOnly) {\n parseType = TagType.void;\n } else if (parseOptions.text) {\n parseType = TagType.text;\n }\n }\n }\n\n enterTag(node);\n return parseType;\n },\n onTagShorthandId(part) {\n currentShorthandId = parseTemplateString(part);\n },\n onTagShorthandClass(part) {\n if (currentShorthandClassNames) {\n currentShorthandClassNames.push(parseTemplateString(part));\n } else {\n currentShorthandClassNames = [parseTemplateString(part)];\n }\n },\n\n onTagVar({ value }) {\n currentTag.node.var = parseVar(\n file,\n parser.read(value),\n value.start,\n value.end,\n );\n },\n\n onTagParams({ value }) {\n currentTag.node.body.params = parseParams(\n file,\n parser.read(value),\n value.start,\n value.end,\n );\n },\n\n onTagArgs({ value }) {\n currentTag.node.arguments = parseArgs(\n file,\n parser.read(value),\n value.start,\n value.end,\n );\n },\n\n onAttrName(part) {\n let name = parser.read(part);\n let modifier = null;\n const modifierIndex = name.lastIndexOf(\":\");\n if (~modifierIndex) {\n modifier = name.slice(modifierIndex + 1);\n name = name.slice(0, modifierIndex);\n }\n\n endAttr();\n currentTag.node.attributes.push(\n (currentAttr = t.markoAttribute(\n name || \"value\",\n t.booleanLiteral(true),\n modifier,\n undefined,\n !name,\n )),\n );\n\n currentAttr.start = part.start;\n currentAttr.end = part.end;\n },\n\n onAttrArgs({ value, end }) {\n currentAttr.arguments = parseArgs(\n file,\n parser.read(value),\n value.start,\n value.end,\n );\n\n currentAttr.end = end;\n },\n\n onAttrValue(part) {\n currentAttr.end = part.end;\n currentAttr.bound = part.bound;\n currentAttr.value = parseExpression(\n file,\n parser.read(part.value),\n part.value.start,\n );\n },\n\n onAttrMethod(part) {\n currentAttr.end = part.end;\n currentAttr.value = withLoc(\n t.functionExpression(\n undefined,\n parseParams(\n file,\n parser.read(part.params.value),\n part.params.value.start,\n part.params.value.end,\n ),\n t.blockStatement(\n parseStatements(\n file,\n parser.read(part.body.value),\n part.body.value.start,\n part.body.value.end,\n ),\n ),\n ),\n part,\n );\n },\n\n onAttrSpread(part) {\n endAttr();\n currentTag.node.attributes.push(\n withLoc(\n t.markoSpreadAttribute(\n parseExpression(file, parser.read(part.value), part.value.start),\n ),\n part,\n ),\n );\n },\n\n onOpenTagEnd(part) {\n const { node } = currentTag;\n const { attributes } = node;\n const parseOptions = node.tagDef?.parseOptions;\n endAttr();\n\n if (currentShorthandClassNames) {\n let foundClassAttr = false;\n const classShorthandValue =\n currentShorthandClassNames.length === 1\n ? currentShorthandClassNames[0]\n : currentShorthandClassNames.every((expr) =>\n t.isStringLiteral(expr),\n )\n ? withLoc(\n t.stringLiteral(\n currentShorthandClassNames\n .map((node) => node.value)\n .join(\" \"),\n ),\n {\n start: currentShorthandClassNames[0].start,\n end: currentShorthandClassNames[\n currentShorthandClassNames.length - 1\n ].end,\n },\n )\n : t.arrayExpression(currentShorthandClassNames);\n\n for (const attr of attributes) {\n if (attr.name === \"class\") {\n foundClassAttr = true;\n if (\n t.isStringLiteral(attr.value) &&\n t.isStringLiteral(classShorthandValue)\n ) {\n attr.value = t.templateLiteral(\n [\n templateElement(\"\", false),\n templateElement(\" \", false),\n templateElement(\"\", true),\n ],\n [classShorthandValue, attr.value],\n );\n } else {\n attr.value = t.arrayExpression(\n t.isArrayExpression(classShorthandValue)\n ? classShorthandValue.elements.concat(\n t.isArrayExpression(attr.value)\n ? attr.value.elements\n : attr.value,\n )\n : t.isArrayExpression(attr.value)\n ? [classShorthandValue].concat(attr.value.elements)\n : [classShorthandValue, attr.value],\n );\n }\n break;\n }\n }\n\n if (!foundClassAttr) {\n attributes.push(t.markoAttribute(\"class\", classShorthandValue));\n }\n\n currentShorthandClassNames = undefined;\n }\n\n if (currentShorthandId) {\n for (const attr of attributes) {\n if (attr.name === \"id\") {\n throw file.buildCodeFrameError(\n attr,\n \"Cannot have shorthand id and id attribute.\",\n );\n }\n }\n attributes.push(t.markoAttribute(\"id\", currentShorthandId));\n currentShorthandId = undefined;\n }\n\n if (parseOptions) {\n if (parseOptions.rawOpenTag) {\n node.rawValue = parser.read({\n start: node.name.start,\n end: part.start,\n });\n }\n\n if (\n part.selfClosed ||\n parseOptions.statement ||\n parseOptions.openTagOnly\n ) {\n this.onCloseTagEnd(part);\n }\n } else if (part.selfClosed) {\n this.onCloseTagEnd(part);\n }\n },\n onCloseTagEnd(part) {\n const { node } = currentTag;\n const tagDef = node.tagDef;\n const parserPlugin = tagDef?.parser;\n if (preservingWhitespaceUntil === node) {\n preservingWhitespaceUntil = undefined;\n }\n\n node.end = part.end;\n node.loc = locationAt(node);\n\n if (parserPlugin) {\n const { hook } = parserPlugin;\n if (parserPlugin.path) watchFiles.push(parserPlugin.path);\n parseVisits.push(hook.default || hook, currentTag);\n }\n\n const parentTag = isAttrTag(node)\n ? currentTag.parentPath\n : currentTag.parentPath.parentPath;\n const { attributeTags } = node;\n\n if (attributeTags.length) {\n const isControlFlow = tagDef?.parseOptions?.controlFlow;\n\n if (node.body.body.length) {\n const body = [];\n // When we have a control flow with mixed body and attribute tag content\n // we move any scriptlets, comments or empty nested control flow.\n // This is because they initially ambiguous as to whether\n // they are part of the body or the attributeTags.\n // Otherwise we only move scriptlets.\n for (const child of node.body.body) {\n if (\n t.isMarkoScriptlet(child) ||\n (isControlFlow && t.isMarkoComment(child))\n ) {\n attributeTags.push(child);\n } else if (\n isControlFlow &&\n child.tagDef?.controlFlow &&\n !child.body.body.length\n ) {\n child.body.attributeTags = true;\n attributeTags.push(child);\n } else {\n body.push(child);\n }\n }\n\n if (isControlFlow) {\n if (body.length) {\n onNext();\n throw file.buildCodeFrameError(\n body[0],\n \"Cannot have attribute tags and body content under a control flow tag.\",\n );\n }\n\n node.attributeTags = body;\n node.body.body = attributeTags;\n node.body.attributeTags = true;\n } else {\n node.body.body = body;\n }\n\n attributeTags.sort(sortByStart);\n } else if (isControlFlow) {\n node.attributeTags = [];\n node.body.body = attributeTags;\n node.body.attributeTags = true;\n }\n\n if (isControlFlow) {\n currentTag.remove();\n parentTag.pushContainer(\"attributeTags\", node);\n }\n }\n\n if (parentTag) {\n currentTag = parentTag;\n currentBody = currentTag.get(\"body\");\n } else {\n currentTag = currentBody = file.path;\n }\n\n onNext();\n },\n });\n\n parser.parse(code);\n onNext();\n\n for (let i = 0; i < parseVisits.length; ) {\n parseVisits[i++](parseVisits[i++]);\n }\n\n const { ast } = file;\n const { program } = ast;\n ast.start = program.start = 0;\n ast.end = program.end = code.length - 1;\n ast.loc = program.loc = {\n start: { line: 1, column: 0 },\n end: positionAt(ast.end),\n };\n}\n\nfunction sortByStart(a, b) {\n return a.start - b.start;\n}\n\nfunction templateElement(value, tail) {\n return t.templateElement({\n tail,\n raw: value,\n cooked: value,\n });\n}\n"
},
{
"path": "packages/compiler/src/babel-plugin/plugins/migrate.js",
"content": "import { getTagDef, getTagDefForTagName } from \"@marko/compiler/babel-utils\";\nimport { types as t } from \"@marko/compiler/internal/babel\";\n\nimport { enter, exit } from \"../util/plugin-hooks\";\n\n/**\n * Applies custom migrators on tags.\n */\nexport const visitor = {\n MarkoTag: {\n enter(path) {\n const migrators = getMigratorsForTag(path);\n const { node } = path;\n for (const migrator of migrators) {\n enter(migrator, path, t);\n if (path.node !== node) break; // Stop if node is replaced.\n }\n },\n exit(path) {\n const migrators = getMigratorsForTag(path);\n const { node } = path;\n for (const migrator of migrators) {\n exit(migrator, path, t);\n if (path.node !== node) break; // Stop if node is replaced.\n }\n },\n },\n};\n\nfunction getMigratorsForTag(path) {\n const {\n hub: { file },\n } = path;\n const { watchFiles } = file.metadata.marko;\n const tagName = path.get(\"name.value\").node || \"*\";\n const MIGRATOR_CACHE = (file.MIGRATOR_CACHE =\n file.MIGRATOR_CACHE || Object.create(null));\n\n let migrators = MIGRATOR_CACHE[tagName];\n\n if (!migrators) {\n migrators = MIGRATOR_CACHE[tagName] = [];\n const addMigrators = (tagDef) => {\n if (tagDef && tagDef.migrators) {\n for (const migrator of tagDef.migrators) {\n if (migrator.path) {\n watchFiles.push(migrator.path);\n }\n migrators.push(migrator.hook.default || migrator.hook);\n }\n }\n };\n\n addMigrators(getTagDef(path));\n\n if (tagName !== \"*\") {\n addMigrators(getTagDefForTagName(file, \"*\"));\n }\n }\n\n return migrators;\n}\n"
},
{
"path": "packages/compiler/src/babel-plugin/plugins/transform.js",
"content": "import { getTagDef, getTagDefForTagName } from \"@marko/compiler/babel-utils\";\nimport { types as t } from \"@marko/compiler/internal/babel\";\n\nimport { enter, exit } from \"../util/plugin-hooks\";\n\n/**\n * Applies custom transformers on tags.\n */\nexport const visitor = {\n MarkoTag: {\n enter(path) {\n const transformers = getTransformersForTag(path);\n const { node } = path;\n\n for (const transformer of transformers) {\n enter(transformer, path, t);\n if (path.node !== node) break; // Stop if node is replaced.\n }\n },\n exit(path) {\n const transformers = getTransformersForTag(path);\n const { node } = path;\n\n for (const transformer of transformers) {\n exit(transformer, path, t);\n if (path.node !== node) break; // Stop if node is replaced.\n }\n },\n },\n};\n\nfunction getTransformersForTag(path) {\n const {\n hub: { file },\n } = path;\n const { watchFiles } = file.metadata.marko;\n const tagName = path.get(\"name.value\").node || \"*\";\n const TRANSFORMER_CACHE = (file.TRANSFORMER_CACHE =\n file.TRANSFORMER_CACHE || Object.create(null));\n\n let transformers = TRANSFORMER_CACHE[tagName];\n\n if (!transformers) {\n transformers = TRANSFORMER_CACHE[tagName] = [];\n const addTransformers = (tagDef) => {\n if (tagDef && tagDef.transformers) {\n for (const transformer of tagDef.transformers) {\n if (transformer.path) {\n watchFiles.push(transformer.path);\n }\n transformers.push(transformer.hook.default || transformer.hook);\n }\n }\n };\n\n addTransformers(getTagDef(path));\n\n if (tagName !== \"*\") {\n addTransformers(getTagDefForTagName(file, \"*\"));\n }\n }\n\n return transformers;\n}\n"
},
{
"path": "packages/compiler/src/babel-plugin/util/plugin-hooks.js",
"content": "// Utilities for executing multi step compiler hooks (migrators & transformers).\n\nexport function enter(plugin, ...args) {\n const fn =\n (plugin &&\n (plugin.enter ||\n (plugin.default && plugin.default.enter) ||\n plugin.default)) ||\n plugin;\n if (typeof fn === \"function\") {\n fn(...args);\n }\n}\n\nexport function exit(plugin, ...args) {\n const fn =\n plugin &&\n (plugin.exit || (plugin.default ? plugin.default.exit : undefined));\n if (typeof fn === \"function\") {\n fn(...args);\n }\n}\n"
},
{
"path": "packages/compiler/src/babel-utils/assert.js",
"content": "export function assertAllowedAttributes(path, allowed) {\n let i = 0;\n for (const attr of path.node.attributes) {\n if (attr.type === \"MarkoSpreadAttribute\") {\n throw path.hub.buildError(\n attr,\n `Tag does not support spread attributes.`,\n );\n } else if (!allowed.includes(attr.name)) {\n throw path.hub.buildError(\n attr,\n `Tag does not support the \\`${attr.name}\\` attribute.`,\n );\n }\n\n i++;\n }\n}\n\nexport function assertNoAttributes(path) {\n const { attributes } = path.node;\n if (attributes.length) {\n const start = attributes[0].loc.start;\n const end = attributes[attributes.length - 1].loc.end;\n throw path.hub.buildError(\n { loc: { start, end } },\n \"Tag does not support attributes.\",\n );\n }\n}\n\nexport function assertNoParams(path) {\n const { params } = path.node.body;\n if (params.length) {\n const start = params[0].loc.start;\n const end = params[params.length - 1].loc.end;\n throw path.hub.buildError(\n { loc: { start, end } },\n \"Tag does not support parameters.\",\n );\n }\n}\n\nexport function assertNoAttributeTags(path) {\n if (path.node.attributeTags.length) {\n throw path.hub.buildError(\n path.node.attributeTags[0],\n \"Tag not support nested attribute tags.\",\n );\n }\n}\n\nexport function assertNoArgs(path) {\n const args = path.node.arguments;\n if (args && args.length) {\n const start = args[0].loc.start;\n const end = args[args.length - 1].loc.end;\n throw path.hub.buildError(\n { loc: { start, end } },\n \"Tag does not support arguments.\",\n );\n }\n}\n\nexport function assertNoVar(path) {\n if (path.node.var) {\n throw path.hub.buildError(\n path.node.var,\n \"Tag does not support a variable.\",\n );\n }\n}\n\nexport function assertAttributesOrArgs(path) {\n const { node } = path;\n const args = node.arguments;\n if (args && args.length && (node.attributes.length > 0 || node.body.length)) {\n const start = args[0].loc.start;\n const end = args[args.length - 1].loc.end;\n throw path.hub.buildError(\n { loc: { start, end } },\n \"Tag does not support arguments when attributes or body present.\",\n );\n }\n}\n\nexport function assertAttributesOrSingleArg(path) {\n assertAttributesOrArgs(path);\n const args = path.node.arguments;\n if (args && args.length > 1) {\n const start = args[1].loc.start;\n const end = args[args.length - 1].loc.end;\n throw path.hub.buildError(\n { loc: { start, end } },\n \"Tag does not support multiple arguments.\",\n );\n }\n}\n"
},
{
"path": "packages/compiler/src/babel-utils/compute.js",
"content": "/**\n * @param {import(\"@babel/types\").Node} node\n */\nexport function computeNode(node) {\n switch (node.type) {\n case \"StringLiteral\":\n case \"NumericLiteral\":\n case \"BooleanLiteral\":\n return { value: node.value };\n case \"RegExpLiteral\":\n return { value: new RegExp(node.pattern, node.flags) };\n case \"NullLiteral\":\n return { value: null };\n case \"Identifier\":\n switch (node.name) {\n case \"undefined\":\n return { value: undefined };\n case \"NaN\":\n return { value: NaN };\n case \"Infinity\":\n return { value: Infinity };\n default:\n return;\n }\n case \"BigIntLiteral\":\n return { value: BigInt(node.value) };\n case \"ParenthesizedExpression\":\n return computeNode(node.expression);\n case \"BinaryExpression\": {\n const left = computeNode(node.left);\n if (!left) return;\n const right = computeNode(node.right);\n if (!right) return;\n switch (node.operator) {\n case \"+\":\n return { value: left.value + right.value };\n case \"-\":\n return { value: left.value - right.value };\n case \"*\":\n return { value: left.value * right.value };\n case \"/\":\n return { value: left.value / right.value };\n case \"%\":\n return { value: left.value % right.value };\n case \"**\":\n return { value: left.value ** right.value };\n case \"|\":\n return { value: left.value | right.value };\n case \"&\":\n return { value: left.value & right.value };\n case \"^\":\n return { value: left.value ^ right.value };\n case \"<<\":\n return { value: left.value << right.value };\n case \">>\":\n return { value: left.value >> right.value };\n case \">>>\":\n return { value: left.value >>> right.value };\n case \"==\":\n return { value: left.value == right.value };\n case \"!=\":\n return { value: left.value != right.value };\n case \"===\":\n return { value: left.value === right.value };\n case \"!==\":\n return { value: left.value !== right.value };\n case \"<\":\n return { value: left.value < right.value };\n case \"<=\":\n return { value: left.value <= right.value };\n case \">\":\n return { value: left.value > right.value };\n case \">=\":\n return { value: left.value >= right.value };\n default:\n return;\n }\n }\n case \"UnaryExpression\": {\n const arg = computeNode(node.argument);\n if (!arg) return;\n switch (node.operator) {\n case \"+\":\n return { value: +arg.value };\n case \"-\":\n return { value: -arg.value };\n case \"~\":\n return { value: ~arg.value };\n case \"!\":\n return { value: !arg.value };\n case \"typeof\":\n return { value: typeof arg.value };\n case \"void\":\n return { value: void arg.value };\n default:\n return;\n }\n }\n case \"LogicalExpression\": {\n const left = computeNode(node.left);\n if (!left) return;\n const right = computeNode(node.right);\n if (!right) return;\n switch (node.operator) {\n case \"&&\":\n return { value: left.value && right.value };\n case \"||\":\n return { value: left.value || right.value };\n case \"??\":\n return { value: left.value ?? right.value };\n default:\n return;\n }\n }\n case \"ConditionalExpression\": {\n const test = computeNode(node.test);\n if (!test) return;\n const consequent = computeNode(node.consequent);\n if (!consequent) return;\n const alternate = computeNode(node.alternate);\n if (!alternate) return;\n return { value: test.value ? consequent.value : alternate.value };\n }\n case \"TemplateLiteral\": {\n let value = node.quasis[0].value.cooked;\n for (let i = 0; i < node.expressions.length; i++) {\n const expr = computeNode(node.expressions[i]);\n if (!expr) return;\n value += expr.value + node.quasis[i + 1].value.cooked;\n }\n return { value };\n }\n case \"ObjectExpression\": {\n const value = {};\n for (const prop of node.properties) {\n if (prop.decorators) return;\n switch (prop.type) {\n case \"ObjectProperty\": {\n let key;\n if (prop.computed) {\n const keyNode = computeNode(prop.key);\n if (!keyNode) return;\n key = keyNode.value + \"\";\n } else {\n switch (prop.key.type) {\n case \"Identifier\":\n key = prop.key.name;\n break;\n case \"StringLiteral\":\n key = prop.key.value;\n break;\n default:\n return;\n }\n }\n\n const propValue = computeNode(prop.value);\n if (!propValue) return;\n value[key] = propValue.value;\n break;\n }\n case \"SpreadElement\": {\n const arg = computeNode(prop.argument);\n if (!arg) return;\n Object.assign(value, arg.value);\n break;\n }\n }\n }\n\n return { value };\n }\n case \"ArrayExpression\": {\n const value = [];\n for (const elem of node.elements) {\n if (elem) {\n if (elem.type === \"SpreadElement\") {\n const arg = computeNode(elem.argument);\n if (typeof arg?.value?.[Symbol.iterator] !== \"function\") return;\n for (const item of arg.value) {\n value.push(item);\n }\n } else {\n const elemValue = computeNode(elem);\n if (!elemValue) return;\n value.push(elemValue.value);\n }\n } else {\n value.length++;\n }\n }\n\n return { value };\n }\n }\n}\n"
},
{
"path": "packages/compiler/src/babel-utils/diagnostics.js",
"content": "export const DiagnosticType = {\n Error: \"error\",\n Warning: \"warning\",\n Deprecation: \"deprecation\",\n Suggestion: \"suggestion\",\n};\n\nexport function diagnosticError(path, options) {\n add(DiagnosticType.Error, path, options);\n}\n\nexport function diagnosticWarn(path, options) {\n add(DiagnosticType.Warning, path, options);\n}\n\nexport function diagnosticDeprecate(path, options) {\n add(DiagnosticType.Deprecation, path, options);\n}\n\nexport function diagnosticSuggest(path, options) {\n add(DiagnosticType.Suggestion, path, options);\n}\n\nfunction add(type, path, options) {\n const { file } = path.hub;\n const { diagnostics } = file.metadata.marko;\n const { label, fix: rawFix, loc = path.node.loc } = options;\n let fix = false;\n\n if (rawFix) {\n switch (file.___compileStage) {\n case \"parse\":\n case \"migrate\":\n break;\n default:\n throw new Error(\n \"Diagnostic fixes can only be registered up to and including the migrate stage.\",\n );\n }\n\n const { applyFixes } = file.markoOpts;\n let apply;\n\n if (typeof rawFix === \"function\") {\n apply = rawFix;\n fix = true;\n } else {\n // strip off the apply function.\n ({ apply, ...fix } = rawFix);\n }\n\n if (applyFixes) {\n const i = diagnostics.length;\n if (applyFixes.has(i)) {\n apply(applyFixes.get(i));\n }\n } else {\n apply(undefined);\n }\n }\n\n diagnostics.push({ type, label, loc, fix });\n}\n"
},
{
"path": "packages/compiler/src/babel-utils/get-file.js",
"content": "let currentFile;\n\nexport function getFile() {\n if (currentFile) {\n return currentFile;\n }\n\n throw new Error(\"Unable to access Marko File outside of a compilation\");\n}\n\nexport function getProgram() {\n if (currentFile) {\n return currentFile.path;\n }\n\n throw new Error(\"Unable to access Marko Program outside of a compilation\");\n}\n\nexport function getFileInternal() {\n return currentFile;\n}\n\nexport function setFileInternal(file) {\n return (currentFile = file);\n}\n"
},
{
"path": "packages/compiler/src/babel-utils/imports.js",
"content": "import { types as t } from \"@marko/compiler\";\nimport { cwd } from \"@marko/compiler/modules\";\nimport path from \"path\";\nimport { relativeImportPath } from \"relative-import-path\";\n\nconst IMPORTS_KEY = Symbol();\nconst FS_START = path.sep === \"/\" ? path.sep : /^(.*?:)/.exec(cwd)[1];\n\nexport function resolveRelativePath(file, request) {\n if (request.startsWith(FS_START)) {\n request = relativeImportPath(file.opts.filename, request);\n }\n\n if (file.markoOpts.optimize) {\n request = request.replace(\n /(^|\\/node-modules\\/)marko\\/src\\//,\n \"$1marko/dist/\",\n );\n }\n\n return request;\n}\n\nexport function importDefault(file, request, nameHint) {\n const imports = getImports(file);\n request = resolveRelativePath(file, request);\n let importDeclaration = imports.get(request);\n\n if (!importDeclaration) {\n imports.set(\n request,\n (importDeclaration = file.path.pushContainer(\n \"body\",\n t.importDeclaration([], t.stringLiteral(request)),\n )[0]),\n );\n }\n\n if (!nameHint) {\n return;\n }\n\n const specifiers = importDeclaration.get(\"specifiers\");\n const specifier = specifiers.find((specifier) =>\n specifier.isImportDefaultSpecifier(),\n );\n\n if (!specifier) {\n const identifier = file.scope.generateUidIdentifier(nameHint);\n importDeclaration.pushContainer(\n \"specifiers\",\n t.importDefaultSpecifier(identifier),\n );\n return identifier;\n }\n\n return t.identifier(specifier.node.local.name);\n}\n\nexport function importNamed(file, request, name, nameHint = name) {\n request = resolveRelativePath(file, request);\n const imports = getImports(file);\n let importDeclaration = imports.get(request);\n\n if (!importDeclaration) {\n imports.set(\n request,\n (importDeclaration = file.path.pushContainer(\n \"body\",\n t.importDeclaration([], t.stringLiteral(request)),\n )[0]),\n );\n }\n\n const specifiers = importDeclaration.get(\"specifiers\");\n const specifier = specifiers.find(\n (specifier) =>\n specifier.isImportSpecifier() && specifier.node.imported.name === name,\n );\n\n if (!specifier) {\n const identifier = file.scope.generateUidIdentifier(nameHint);\n importDeclaration.pushContainer(\n \"specifiers\",\n t.importSpecifier(identifier, t.identifier(name)),\n );\n return identifier;\n }\n\n return t.identifier(specifier.node.local.name);\n}\n\nexport function importStar(file, request, nameHint) {\n const imports = getImports(file);\n request = resolveRelativePath(file, request);\n let importDeclaration = imports.get(request);\n\n if (!importDeclaration) {\n imports.set(\n request,\n (importDeclaration = file.path.pushContainer(\n \"body\",\n t.importDeclaration([], t.stringLiteral(request)),\n )[0]),\n );\n }\n\n if (!nameHint) {\n return;\n }\n\n const specifiers = importDeclaration.get(\"specifiers\");\n const specifier = specifiers.find((specifier) =>\n specifier.isImportNamespaceSpecifier(),\n );\n\n if (!specifier) {\n const identifier = file.scope.generateUidIdentifier(nameHint);\n importDeclaration.pushContainer(\n \"specifiers\",\n t.importNamespaceSpecifier(identifier),\n );\n return identifier;\n }\n\n return t.identifier(specifier.node.local.name);\n}\n\nfunction getImports(file) {\n let imports = file.metadata.marko[IMPORTS_KEY];\n\n if (!imports) {\n imports = file.metadata.marko[IMPORTS_KEY] = new Map();\n }\n\n return imports;\n}\n"
},
{
"path": "packages/compiler/src/babel-utils/index.js",
"content": "export {\n assertAllowedAttributes,\n assertAttributesOrArgs,\n assertAttributesOrSingleArg,\n assertNoArgs,\n assertNoAttributes,\n assertNoAttributeTags,\n assertNoParams,\n assertNoVar,\n} from \"./assert\";\nexport { computeNode } from \"./compute\";\nexport {\n diagnosticDeprecate,\n diagnosticError,\n diagnosticSuggest,\n DiagnosticType,\n diagnosticWarn,\n} from \"./diagnostics\";\nexport { getFile, getProgram } from \"./get-file\";\nexport {\n importDefault,\n importNamed,\n importStar,\n resolveRelativePath,\n} from \"./imports\";\nexport { getEnd, getLoc, getLocRange, getStart, withLoc } from \"./loc\";\nexport {\n parseArgs,\n parseExpression,\n parseParams,\n parseStatements,\n parseTemplateLiteral,\n parseTypeArgs,\n parseTypeParams,\n parseVar,\n} from \"./parse\";\nexport { getTagDefForTagName, getTaglibLookup } from \"./taglib\";\nexport {\n findAttributeTags,\n findParentTag,\n getArgOrSequence,\n getFullyResolvedTagName,\n getMacroIdentifier,\n getMacroIdentifierForName,\n getTagDef,\n getTagTemplate,\n getTemplateId,\n hasMacro,\n isAttributeTag,\n isDynamicTag,\n isLoopTag,\n isMacroTag,\n isNativeTag,\n isTransparentTag,\n loadFileForImport,\n loadFileForTag,\n registerMacro,\n resolveTagImport,\n} from \"./tags\";\nexport { normalizeTemplateString } from \"./template-string\";\n\nexport function defineTag(tag) {\n return tag;\n} // just used for adding types for compiler plugins.\n"
},
{
"path": "packages/compiler/src/babel-utils/loc.js",
"content": "const LINE_INDEX_KEY = Symbol();\n\nexport function getLoc(file, index) {\n return findLoc(getLineIndexes(file), 0, index);\n}\n\nexport function getLocRange(file, start, end) {\n const lineIndexes = getLineIndexes(file);\n const startLoc = findLoc(lineIndexes, 0, start);\n\n if (startLoc) {\n const endLoc =\n start === end ? startLoc : findLoc(lineIndexes, startLoc.line - 1, end);\n\n return {\n start: startLoc,\n end: endLoc,\n };\n }\n}\n\nexport function withLoc(file, node, start, end) {\n node.loc = getLocRange(file, start, end);\n node.start = start;\n node.end = end;\n return node;\n}\n\nexport function getStart(file, node) {\n // Restore if merged: https://github.com/babel/babel/pull/16849\n // if (node.start != null) {\n // return node.start;\n // }\n\n if (node.loc) {\n return locToIndex(file, node.loc.start);\n }\n\n return null;\n}\n\nexport function getEnd(file, node) {\n // Restore if merged: https://github.com/babel/babel/pull/16849\n // if (node.end != null) {\n // return node.end;\n // }\n\n if (node.loc) {\n return locToIndex(file, node.loc.end);\n }\n\n return null;\n}\n\nfunction locToIndex(file, loc) {\n const { line, column } = loc;\n return line === 1 ? column : getLineIndexes(file)[line - 1] + column + 1;\n}\n\nfunction getLineIndexes(file) {\n let lineIndexes = file.metadata.marko[LINE_INDEX_KEY];\n\n if (!lineIndexes) {\n lineIndexes = [-1];\n for (let i = 0; i < file.code.length; i++) {\n if (file.code[i] === \"\\n\") {\n lineIndexes.push(i);\n }\n }\n\n file.metadata.marko[LINE_INDEX_KEY] = lineIndexes;\n }\n\n return lineIndexes;\n}\n\nfunction findLoc(lineIndexes, startLine, index) {\n if (index <= 0) {\n return {\n line: 1,\n column: 0,\n };\n }\n\n const endLine = lineIndexes.length - 1;\n let max = endLine;\n let line = startLine;\n\n while (line < max) {\n const mid = (line + max) >>> 1;\n if (lineIndexes[mid] < index) {\n line = mid + 1;\n } else {\n max = mid;\n }\n }\n\n let lineIndex = lineIndexes[line];\n if (lineIndex >= index) {\n lineIndex = lineIndexes[--line];\n }\n\n if (line === 0) {\n return {\n line: 1,\n column: index,\n };\n }\n\n return {\n line: line + 1,\n column: index - lineIndex - 1,\n };\n}\n"
},
{
"path": "packages/compiler/src/babel-utils/parse.js",
"content": "import { types as t } from \"@marko/compiler\";\nimport {\n parse as babelParse,\n parseExpression as babelParseExpression,\n} from \"@marko/compiler/internal/babel\";\n\nimport { getLoc, getLocRange } from \"./loc\";\n\nexport function parseStatements(\n file,\n str,\n sourceStart,\n sourceEnd,\n sourceOffset,\n) {\n return tryParse(file, false, str, sourceStart, sourceEnd, sourceOffset);\n}\n\nexport function parseExpression(\n file,\n str,\n sourceStart,\n sourceEnd,\n sourceOffset,\n) {\n return tryParse(file, true, str, sourceStart, sourceEnd, sourceOffset);\n}\n\nexport function parseParams(file, str, sourceStart, sourceEnd) {\n const parsed = parseExpression(\n file,\n `(${str})=>{}`,\n sourceStart,\n sourceEnd,\n 1,\n );\n\n if (parsed.type === \"ArrowFunctionExpression\") {\n return parsed.params;\n }\n\n return [ensureParseError(file, parsed, sourceStart, sourceEnd)];\n}\n\nexport function parseArgs(file, str, sourceStart, sourceEnd) {\n const parsed = parseExpression(file, `_(${str})`, sourceStart, sourceEnd, 2);\n\n if (parsed.type === \"CallExpression\") {\n return parsed.arguments;\n }\n\n return [ensureParseError(file, parsed, sourceStart, sourceEnd)];\n}\n\nexport function parseVar(file, str, sourceStart, sourceEnd) {\n const parsed = parseExpression(\n file,\n `(${str})=>{}`,\n sourceStart,\n sourceEnd,\n 1,\n );\n\n if (parsed.type === \"ArrowFunctionExpression\" && parsed.params.length === 1) {\n return parsed.params[0];\n }\n\n return ensureParseError(file, parsed, sourceStart, sourceEnd);\n}\n\nexport function parseTemplateLiteral(file, str, sourceStart, sourceEnd) {\n const parsed = parseExpression(\n file,\n \"`\" + str + \"`\",\n sourceStart,\n sourceEnd,\n 1,\n );\n\n if (parsed.type === \"TemplateLiteral\") {\n return t.templateLiteral(parsed.quasis, parsed.expressions);\n }\n\n return ensureParseError(file, parsed, sourceStart, sourceEnd);\n}\n\nexport function parseTypeArgs(file, str, sourceStart, sourceEnd) {\n const parsed = parseExpression(file, `_<${str}>`, sourceStart, sourceEnd, 2);\n\n if (parsed.type === \"TSInstantiationExpression\") {\n // typeArguments is Flow only (not TS), we need to use typeParameters\n return parsed.typeParameters;\n }\n\n return [ensureParseError(file, parsed, sourceStart, sourceEnd)];\n}\n\nexport function parseTypeParams(file, str, sourceStart, sourceEnd) {\n const parsed = parseExpression(\n file,\n `<${str}>()=>{}`,\n sourceStart,\n sourceEnd,\n 1,\n );\n\n if (parsed.type === \"ArrowFunctionExpression\") {\n return parsed.typeParameters;\n }\n\n return [ensureParseError(file, parsed, sourceStart, sourceEnd)];\n}\n\nfunction tryParse(\n file,\n isExpression,\n code,\n sourceStart,\n sourceEnd,\n sourceOffset,\n) {\n const { parserOpts } = file.opts;\n\n if (typeof sourceStart === \"number\") {\n const startLoc = getLoc(file, sourceStart);\n const startLine = startLoc.line;\n let startIndex = sourceStart;\n let startColumn = startLoc.column;\n\n if (sourceOffset) {\n startIndex -= sourceOffset;\n startColumn -= sourceOffset;\n }\n\n parserOpts.startLine = startLine;\n parserOpts.startIndex = startIndex;\n parserOpts.startColumn = startColumn;\n\n try {\n if (isExpression) {\n return babelParseExpression(code, parserOpts);\n } else {\n const { program } = babelParse(code, parserOpts);\n if (program.innerComments) {\n const lastNode = t.emptyStatement();\n lastNode.trailingComments = program.innerComments;\n program.body.push(lastNode);\n }\n return program.body;\n }\n } catch (err) {\n const parseError = createParseError(\n file,\n sourceStart,\n sourceEnd,\n err.message,\n err.loc,\n );\n\n if (isExpression) {\n return parseError;\n } else {\n return [parseError];\n }\n } finally {\n parserOpts.startIndex = 0;\n parserOpts.startColumn = 0;\n parserOpts.startLine = 1;\n }\n } else {\n return isExpression\n ? t.cloneDeepWithoutLoc(babelParseExpression(code, parserOpts))\n : babelParse(code, parserOpts).program.body.map((node) =>\n t.cloneDeepWithoutLoc(node),\n );\n }\n}\n\nfunction ensureParseError(file, node, sourceStart, sourceEnd) {\n if (node.type === \"MarkoParseError\") return node;\n return createParseError(\n file,\n sourceStart,\n sourceEnd,\n `Unexpected node of type ${node.type} returned while parsing.`,\n );\n}\n\nfunction createParseError(file, sourceStart, sourceEnd, label, errorLoc) {\n file.___hasParseErrors = true;\n const loc = getLocRange(file, sourceStart, sourceEnd);\n return {\n type: \"MarkoParseError\",\n source: file.code.slice(sourceStart, sourceEnd),\n label: label.replace(/ *\\(\\d+:\\d+\\)$/, \"\"),\n errorLoc: errorLoc && getBoundedRange(loc, errorLoc),\n loc,\n start: sourceStart,\n end: sourceEnd,\n };\n}\n\nfunction getBoundedRange(range, loc) {\n if (loc && typeof loc.line === \"number\") {\n const { start, end } = range;\n // If start is out of bounds return the source.\n if (\n loc.line < start.line ||\n (loc.line === start.line && loc.column < start.column) ||\n loc.line > end.line ||\n (loc.line === end.line && loc.column > end.column)\n ) {\n return range;\n }\n\n return { start: loc, end: loc };\n }\n}\n"
},
{
"path": "packages/compiler/src/babel-utils/taglib.js",
"content": "const SEEN_TAGS_KEY = Symbol();\n\nexport function getTaglibLookup(file) {\n return file.___taglibLookup;\n}\n\nexport function getTagDefForTagName(file, tagName) {\n const tagDef = getTaglibLookup(file).getTag(tagName);\n\n if (tagDef) {\n let seen = file.metadata.marko[SEEN_TAGS_KEY];\n if (!seen) {\n seen = file.metadata.marko[SEEN_TAGS_KEY] = new Set();\n }\n\n if (!seen.has(tagDef)) {\n seen.add(tagName);\n const { filePath } = tagDef;\n const len = filePath.length;\n\n if (filePath[len - 14] === \"m\" && filePath.endsWith(\"marko-tag.json\")) {\n file.metadata.marko.watchFiles.push(filePath);\n }\n }\n }\n return tagDef;\n}\n"
},
{
"path": "packages/compiler/src/babel-utils/tags.js",
"content": "import { types as t } from \"@marko/compiler\";\nimport markoModules from \"@marko/compiler/modules\";\nimport { basename, dirname, join, relative, resolve } from \"path\";\n\nimport { Hash } from \"../util/quick-hash\";\nimport { diagnosticWarn } from \"./diagnostics\";\nimport { resolveRelativePath } from \"./imports\";\nimport { getTagDefForTagName } from \"./taglib\";\n\nconst { cwd, root } = markoModules;\nconst MACRO_IDS_KEY = Symbol();\nconst MACRO_NAMES_KEY = \"__marko_macro_names__\"; // must be a string literal since it is used across compiler stages.\nconst TRANSPARENT_TAGS = new Set([\n \"for\",\n \"while\",\n \"if\",\n \"else\",\n \"else-if\",\n \"_no-update\",\n]);\n\nexport function isNativeTag(path) {\n if (path.node._isDynamicString) {\n return true;\n }\n\n const tagDef = getTagDef(path);\n return (\n tagDef &&\n tagDef.html &&\n (tagDef.htmlType === \"custom-element\" ||\n (!tagDef.template && !tagDef.renderer))\n );\n}\n\nexport function isDynamicTag(path) {\n return !t.isStringLiteral(path.node.name);\n}\n\nexport function isAttributeTag(path) {\n const {\n node: { name },\n } = path;\n return t.isStringLiteral(name) && name.value[0] === \"@\";\n}\n\nexport function isTransparentTag(path) {\n const {\n node: { name },\n } = path;\n return t.isStringLiteral(name) && TRANSPARENT_TAGS.has(name.value);\n}\n\nexport function registerMacro(path, name) {\n const { file } = path.hub;\n const markoMeta = file.metadata.marko;\n const macroNames = markoMeta[MACRO_NAMES_KEY];\n\n if (macroNames) {\n if (macroNames[name]) {\n diagnosticWarn(path, {\n label: `A macro with the name \"${name}\" already exists.`,\n fix() {\n findParentTag(path).remove();\n },\n });\n }\n macroNames[name] = true;\n } else {\n markoMeta[MACRO_NAMES_KEY] = { [name]: true };\n }\n}\n\nexport function hasMacro(path, name) {\n const macroNames = path.hub.file.metadata.marko[MACRO_NAMES_KEY];\n return !!(macroNames && macroNames[name]);\n}\n\nexport function isMacroTag(path) {\n const { name } = path.node;\n return t.isStringLiteral(name) && hasMacro(path, name.value);\n}\n\nexport function getMacroIdentifierForName(path, name) {\n const { file } = path.hub;\n\n if (file.___compileStage !== \"translate\") {\n throw new Error(\n \"getMacroIdentifierForName can only be called during the translate phase of the compiler.\",\n );\n }\n\n const markoMeta = file.metadata.marko;\n let macroIds = markoMeta[MACRO_IDS_KEY];\n\n if (!macroIds) {\n macroIds = markoMeta[MACRO_IDS_KEY] = {};\n\n for (const macroName in markoMeta[MACRO_NAMES_KEY]) {\n macroIds[macroName] = file.path.scope.generateUid(macroName);\n }\n }\n\n const id = macroIds[name];\n\n if (!id) {\n throw new Error(\n \" was added programmatically, but was not registered via the 'registerMacro' api in @marko/compiler/babel-utils.\",\n );\n }\n\n return t.identifier(id);\n}\n\nexport function getMacroIdentifier(path) {\n const { file } = path.hub;\n\n if (file.___compileStage !== \"translate\") {\n throw new Error(\n \"getMacroIdentifier can only be called during the translate phase of the compiler.\",\n );\n }\n\n if (!isMacroTag(path)) {\n throw path.buildCodeFrameError(\n \"getMacroIdentifier called on non macro referencing tag.\",\n );\n }\n\n return getMacroIdentifierForName(path, path.node.name.value);\n}\n\nexport function getTagTemplate(tag) {\n const {\n node,\n hub: { file },\n } = tag;\n\n if (node.extra?.tagNameImported) {\n return join(file.opts.filename, node.extra.tagNameImported);\n }\n return getTagDef(tag)?.template;\n}\n\nexport function getTagDef(path) {\n const {\n node,\n hub: { file },\n } = path;\n\n if (node.tagDef === undefined) {\n if (isDynamicTag(path) || isMacroTag(path)) {\n node.tagDef = null;\n } else {\n node.tagDef =\n getTagDefForTagName(\n file,\n isAttributeTag(path)\n ? getFullyResolvedTagName(path)\n : node.name.value,\n ) || null;\n }\n }\n\n return node.tagDef;\n}\n\nexport function getFullyResolvedTagName(path) {\n const parts = [];\n let cur;\n do {\n cur = path.node.name.value;\n\n if (isAttributeTag(path)) {\n parts.push(cur.slice(1));\n } else {\n parts.push(cur || \"*\");\n break;\n }\n } while ((path = findParentTag(path)));\n\n return parts.reverse().join(\":\");\n}\n\nexport function findParentTag(path) {\n let cur = path.parentPath;\n\n while (cur.node) {\n if (cur.isMarkoTagBody()) {\n cur = cur.parentPath;\n continue;\n }\n\n if (!cur.isMarkoTag()) {\n break;\n }\n\n if (isTransparentTag(cur)) {\n cur = cur.parentPath;\n continue;\n }\n\n return cur;\n }\n}\n\nexport function findAttributeTags(path, attributeTags = []) {\n const attrTags = path.node.body.attributeTags\n ? path.get(\"body\").get(\"body\")\n : path.get(\"attributeTags\");\n attrTags.forEach((child) => {\n if (isAttributeTag(child)) {\n attributeTags.push(child);\n } else if (isTransparentTag(child)) {\n findAttributeTags(child, attributeTags);\n }\n });\n\n return attributeTags;\n}\n\nexport function getArgOrSequence(path) {\n const {\n node: { arguments: args },\n } = path;\n const len = args && args.length;\n\n if (len) {\n if (len > 1) {\n return t.sequenceExpression(args);\n } else {\n return args[0];\n }\n }\n}\n\nexport function isLoopTag(path) {\n if (!path.isMarkoTag()) {\n return false;\n }\n\n const tagName = path.node.name.value;\n return tagName === \"while\" || tagName === \"for\";\n}\n\nexport function loadFileForTag(tag) {\n const { file } = tag.hub;\n if (tag.node.extra?.tagNameImported) {\n return loadFileForImport(file, tag.node.extra?.tagNameImported);\n }\n\n const def = getTagDef(tag);\n const filename = def && def.template;\n\n if (filename) {\n return resolveMarkoFile(file, filename);\n }\n}\n\nexport function loadFileForImport(file, request) {\n const relativeRequest = resolveTagImport(file.path, request);\n if (relativeRequest) {\n const filename =\n relativeRequest[0] === \".\"\n ? resolve(file.opts.filename, \"..\", relativeRequest)\n : markoModules.resolve(relativeRequest, dirname(file.opts.filename));\n return resolveMarkoFile(file, filename);\n }\n}\n\nfunction resolveMarkoFile(file, filename) {\n if (filename === file.opts.filename) {\n if (file.___compileStage === \"analyze\") {\n return file;\n }\n\n return file.___getMarkoFile(file.code, file.opts, file.markoOpts);\n }\n\n try {\n const childFile = file.___getMarkoFile(\n file.markoOpts.fileSystem.readFileSync(filename).toString(\"utf-8\"),\n createNewFileOpts(file.opts, filename),\n file.markoOpts,\n );\n\n (file.metadata.marko.analyzedTags ||= new Set()).add(filename);\n return childFile;\n } catch (_) {\n // ignore\n }\n}\n\nconst idCache = new WeakMap();\nconst templateIdHashOpts = { outputLength: 5 };\nexport function getTemplateId(opts, request, child) {\n if (!child && opts.getTemplateId) return opts.getTemplateId(request);\n\n const id = relative(root, request).replace(/[^a-zA-Z0-9_$./-]/g, \"/\");\n\n if (opts.optimize) {\n const optimizeKnownTemplates =\n typeof opts === \"object\" && opts.optimizeKnownTemplates;\n const knownTemplatesSize = optimizeKnownTemplates?.length || 0;\n if (knownTemplatesSize) {\n let lookup = idCache.get(optimizeKnownTemplates);\n if (!lookup) {\n lookup = new Map();\n idCache.set(optimizeKnownTemplates, lookup);\n for (let i = 0; i < knownTemplatesSize; i++) {\n lookup.set(optimizeKnownTemplates[i], {\n id: encodeTemplateId(i),\n children: new Map(),\n });\n }\n }\n let registered = lookup.get(request);\n if (registered) {\n if (child) {\n let childId = registered.children.get(child);\n if (childId === undefined) {\n childId = registered.children.size;\n registered.children.set(child, childId);\n }\n return registered.id + childId;\n }\n return registered.id;\n }\n }\n\n const hash = new Hash().update(id);\n if (child) {\n hash.update(child);\n }\n\n return encodeTemplateId(hash.digest());\n }\n\n return id + (child ? `_${child}` : \"\");\n}\n\nexport function resolveTagImport(path, request) {\n const {\n hub: { file },\n } = path;\n if (request[0] === \"<\") {\n const tagName = request.slice(1, -1);\n const tagDef = getTagDefForTagName(file, tagName);\n const tagEntry = tagDef && (tagDef.renderer || tagDef.template);\n const relativePath = tagEntry && resolveRelativePath(file, tagEntry);\n\n if (!relativePath) {\n throw path.buildCodeFrameError(\n `Unable to find entry point for custom tag <${tagName}>.`,\n );\n }\n\n return relativePath;\n }\n\n if (request.endsWith(\".marko\")) {\n return resolveRelativePath(file, request);\n }\n}\n\nfunction createNewFileOpts(opts, filename) {\n const sourceFileName = basename(filename);\n const sourceRoot = dirname(filename);\n const filenameRelative = relative(cwd, filename);\n return {\n ...opts,\n filename,\n sourceRoot,\n sourceFileName,\n filenameRelative,\n parserOpts: {\n ...opts.parserOpts,\n sourceFileName,\n },\n generatorOpts: {\n ...opts.generatorOpts,\n filename,\n sourceRoot,\n sourceFileName,\n },\n };\n}\n\nfunction encodeTemplateId(id) {\n const c = \"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_0123456789\";\n let n = id;\n let r = c[n % 53]; // Avoids chars that cannot start a property name and _ (reserved).\n n = Math.floor(n / 53);\n\n // ensure at most 7 characters.\n for (let i = 6; n > 0 && i--; n = Math.floor(n / 64)) {\n r += c[n & 63];\n }\n\n return r;\n}\n"
},
{
"path": "packages/compiler/src/babel-utils/template-string.js",
"content": "import { types as t } from \"@marko/compiler\";\nimport jsesc from \"jsesc\";\n\nexport function normalizeTemplateString(quasis, ...expressions) {\n quasis = quasis.map((q) => (t.isTemplateElement(q) ? q.value.cooked : q));\n\n for (let i = expressions.length; i--; ) {\n let v = expressions[i];\n if (t.isTemplateLiteral(v)) {\n quasis[i] += v.quasis[0].value.cooked;\n quasis[i + 1] =\n v.quasis[v.quasis.length - 1].value.cooked + (quasis[i + 1] || \"\");\n quasis.splice(\n i + 1,\n 0,\n ...v.quasis.slice(1, -1).map((q) => q.value.cooked),\n );\n expressions.splice(i, 1, ...v.expressions);\n i += v.expressions.length;\n } else if (t.isStringLiteral(v) || typeof v === \"string\") {\n const value = t.isStringLiteral(v) ? v.value : v;\n quasis[i] += value + quasis[i + 1];\n expressions.splice(i, 1);\n quasis.splice(i + 1, 1);\n }\n }\n\n if (!expressions.length) {\n // No expression, just return a literal or empty.\n const literal = quasis.join(\"\");\n return literal === \"\" ? undefined : t.stringLiteral(literal);\n }\n\n if (\n expressions.length === 1 &&\n quasis.length === 2 &&\n quasis.every(isEmptyString)\n ) {\n // Only expression `${expr}` just return the expr.\n return expressions[0];\n }\n\n // Do it.\n return t.templateLiteral(quasis.map(getTemplateElement), expressions);\n}\n\nfunction getTemplateElement(s = \"\") {\n return t.templateElement({\n cooked: s,\n raw: jsesc(s, { quotes: \"backtick\" }),\n });\n}\n\nfunction isEmptyString(s = \"\") {\n return s === \"\";\n}\n"
},
{
"path": "packages/compiler/src/config.js",
"content": "import { pkg } from \"@marko/compiler/modules\";\nimport fs from \"fs\";\n\nconst config = {\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 /**\n * Remove all typescript types from the output.\n * By default, the compiler will remove types from the output if the\n * `output` option is not `source` or `migrate`.\n */\n stripTypes: undefined,\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-)runtime-/;\n const translatorInterop = \"@marko/translator-interop-class-tags\";\n let translator;\n\n if (pkg) {\n if (\n pkg.dependencies?.[translatorInterop] ||\n pkg.devDependencies?.[translatorInterop]\n ) {\n return translatorInterop;\n }\n\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 if (translator) {\n translator += \"/translator\";\n }\n\n return translator || \"marko/translator\";\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 * If `optimize` is enabled you can provide an array of template paths which the compiler will\n * use to generate shorter registry/template ids using incrementing ids. This can only be used\n * if the same `optimizeKnownTemplates` are used for both server and client compilations.\n */\n optimizeKnownTemplates: 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 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 * When compiling in hydrate mode, this option will cause the compiler to\n * call the `marko/components.init` function to begin hydrating components.\n */\n hydrateInit: true,\n\n /**\n * Set to true in order to bring in the hot module replacement runtime.\n */\n hot: false,\n\n /**\n * Wether error diagnostics should be thrown as errors\n * before the compile result is returned.\n *\n * Note that the compiler can still throw errors even when true.\n * When the errorRecovery is true, any recoverable errors will be\n * returned in the `meta.diagnostics` property of the compile result.\n */\n errorRecovery: false,\n\n // When supplied, any diagnostics which have a fix specified in the lookup will be applied to the source code.\n applyFixes: undefined,\n};\n\nif (\n typeof process === \"object\" &&\n typeof process.env === \"object\" &&\n process.env.MARKO_CONFIG\n) {\n Object.assign(config, JSON.parse(process.env.MARKO_CONFIG));\n}\n\nexport default config;\n\nimport taglibConfig from \"./taglib/config\";\ntaglibConfig.fs = config.fileSystem;\n"
},
{
"path": "packages/compiler/src/index.js",
"content": "import { DiagnosticType } from \"@marko/compiler/babel-utils\";\nimport {\n loadPartialConfig,\n loadPartialConfigAsync,\n pluginTransformModulesCommonjs,\n transformAsync,\n transformSync,\n types,\n} from \"@marko/compiler/internal/babel\";\nimport markoModules from \"@marko/compiler/modules\";\nimport path from \"path\";\n\nimport corePlugin from \"./babel-plugin\";\nimport defaultConfig from \"./config\";\nimport * as taglib from \"./taglib\";\nimport { buildCodeFrameError } from \"./util/build-code-frame\";\nimport throwAggregateError from \"./util/merge-errors\";\nimport shouldOptimize from \"./util/should-optimize\";\nimport tryLoadTranslator from \"./util/try-load-translator\";\nexport { taglib, types };\n\nconst hasBabel = !!(\n markoModules.pkg &&\n (markoModules.pkg.dependencies?.[\"@babel/core\"] ||\n markoModules.pkg.devDependencies?.[\"@babel/core\"])\n);\nexport let globalConfig = { ...defaultConfig };\nexport function configure(newConfig) {\n globalConfig = { ...defaultConfig, ...newConfig };\n}\n\nexport async function compile(src, filename, config) {\n const markoConfig = loadMarkoConfig(config);\n const babelConfig = await loadBabelConfig(filename, markoConfig);\n const babelResult = await transformAsync(src, babelConfig);\n return buildResult(src, filename, markoConfig.errorRecovery, babelResult);\n}\n\nexport function compileSync(src, filename, config) {\n const markoConfig = loadMarkoConfig(config);\n const babelConfig = loadBabelConfigSync(filename, markoConfig);\n const babelResult = transformSync(src, babelConfig);\n return buildResult(src, filename, markoConfig.errorRecovery, 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 loadMarkoConfig(config) {\n const markoConfig = { ...globalConfig, ...config };\n\n if (markoConfig.stripTypes === undefined) {\n markoConfig.stripTypes = isTranslatedOutput(markoConfig.output);\n }\n\n return markoConfig;\n}\n\nasync function loadBabelConfig(filename, config) {\n const baseBabelConfig = getBaseBabelConfig(filename, config);\n return shouldResolveBabelConfig(config)\n ? (await loadPartialConfigAsync(baseBabelConfig)).options\n : baseBabelConfig;\n}\n\nfunction loadBabelConfigSync(filename, config) {\n const baseBabelConfig = getBaseBabelConfig(filename, config);\n return shouldResolveBabelConfig(config)\n ? loadPartialConfig(baseBabelConfig).options\n : baseBabelConfig;\n}\n\nfunction shouldResolveBabelConfig(config) {\n return !!(\n config.babelrc ||\n config.configFile ||\n config.browserslistConfigFile\n );\n}\n\nfunction getBaseBabelConfig(filename, { babelConfig, ...markoConfig }) {\n const isTranslated = isTranslatedOutput(markoConfig.output);\n const loadConfig = isTranslated && hasBabel;\n const requiredPlugins = [[corePlugin, markoConfig]];\n const baseBabelConfig = {\n filenameRelative: filename\n ? path.relative(markoModules.cwd, filename)\n : undefined,\n sourceRoot: filename ? path.dirname(filename) : undefined,\n sourceFileName: filename ? path.basename(filename) : undefined,\n babelrc: loadConfig,\n configFile: loadConfig,\n browserslistConfigFile: loadConfig,\n ...babelConfig,\n filename,\n sourceType: \"module\",\n sourceMaps: markoConfig.sourceMaps,\n code: markoConfig.code,\n ast: markoConfig.ast,\n plugins:\n babelConfig && babelConfig.plugins\n ? requiredPlugins.concat(babelConfig.plugins)\n : requiredPlugins,\n };\n\n if (isTranslated) {\n if (markoConfig.modules === \"cjs\") {\n baseBabelConfig.plugins.push([\n pluginTransformModulesCommonjs,\n { loose: true },\n ]);\n }\n }\n\n return baseBabelConfig;\n}\n\nfunction buildResult(src, filename, errorRecovery, babelResult) {\n const {\n ast,\n map,\n code,\n metadata: { marko: meta },\n } = babelResult;\n\n if (!errorRecovery) {\n const errors = [];\n\n for (const diag of meta.diagnostics) {\n if (diag.type === DiagnosticType.Error) {\n errors.push(buildCodeFrameError(filename, src, diag.loc, diag.label));\n }\n }\n\n throwAggregateError(errors);\n }\n\n return { ast, map, code, meta };\n}\n\nexport function _clearDefaults() {\n globalConfig.cache.clear();\n}\n\nfunction getFs(config) {\n return config.fileSystem || globalConfig.fileSystem;\n}\n\nfunction isTranslatedOutput(output) {\n return output !== \"source\" && output !== \"migrate\";\n}\n"
},
{
"path": "packages/compiler/src/register.js",
"content": "\"use strict\";\n\nconst shouldOptimize = require(\"./util/should-optimize\").default;\nconst compiler = require(\".\");\nconst requiredOptions = { modules: \"cjs\" };\nconst isDev = !shouldOptimize();\nlet setSourceMap = (filename, map) => {\n const sourceMaps = new Map([[filename, map]]);\n require(\"source-map-support\").install({\n handleUncaughtExceptions: false,\n environment: \"node\",\n retrieveSourceMap(source) {\n const map = sourceMaps.get(source);\n if (map) {\n return { url: null, map };\n }\n return null;\n },\n });\n\n setSourceMap = (filename, map) => {\n sourceMaps.set(filename, map);\n };\n};\n\nmodule.exports = register;\nregister();\n\nfunction register({ extensions = require.extensions, ...options } = {}) {\n extensions[\".marko\"] = (module, filename) => {\n const compiled = compiler.compileFileSync(\n filename,\n Object.assign(\n {\n meta: true,\n hot: process.env.BROWSER_REFRESH_URL !== undefined,\n sourceMaps: isDev ? \"both\" : false,\n },\n options,\n requiredOptions,\n ),\n );\n\n if (compiled.map) {\n setSourceMap(filename, compiled.map);\n }\n\n return module._compile(compiled.code, filename);\n };\n\n return extensions;\n}\n"
},
{
"path": "packages/compiler/src/taglib/config.js",
"content": "module.exports = {\n fs: undefined,\n onError: (err) => {\n throw err;\n },\n};\n"
},
{
"path": "packages/compiler/src/taglib/finder/index.js",
"content": "\"use strict\";\nvar nodePath = require(\"path\");\nvar lassoPackageRoot = require(\"lasso-package-root\");\nvar markoModules = require(\"@marko/compiler/modules\");\nvar taglibConfig = require(\"../config\");\nvar taglibLoader = require(\"../loader\");\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, tagDiscoveryDirs) {\n var cached = findCache[dirname];\n if (cached) {\n return cached.taglibs;\n }\n\n var taglibs = [];\n var added = new Set();\n var rootDirname = markoModules.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 // exclusiveTagDiscoveryDirs is used for the interop to detect if `tags` directories are used exclusively when finding tags\n let exclusiveTagDiscoveryDirs = undefined;\n\n while (true) {\n if (!excludedDirs[curDirname]) {\n let taglibPath = nodePath.join(curDirname, \"marko.json\");\n let taglib;\n let manualTagsDir;\n\n if (existsSync(taglibPath)) {\n taglib = taglibLoader.loadTaglibFromFile(taglibPath);\n manualTagsDir = taglib.tagsDir;\n addTaglib(taglib);\n }\n\n if (manualTagsDir === undefined) {\n for (const tagDiscoveryDir of tagDiscoveryDirs) {\n const componentsPath = nodePath.join(curDirname, tagDiscoveryDir);\n\n if (existsSync(componentsPath) && !excludedDirs[componentsPath]) {\n if (exclusiveTagDiscoveryDirs !== false) {\n if (exclusiveTagDiscoveryDirs === undefined) {\n exclusiveTagDiscoveryDirs = tagDiscoveryDir;\n } else if (exclusiveTagDiscoveryDirs !== tagDiscoveryDir) {\n exclusiveTagDiscoveryDirs = false;\n }\n }\n\n addTaglib(\n taglibLoader.loadTaglibFromDir(curDirname, tagDiscoveryDir),\n );\n }\n }\n } else if (manualTagsDir) {\n exclusiveTagDiscoveryDirs = false;\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 = markoModules.tryResolve(\n name + \"/marko.json\",\n rootPkg.__dirname,\n );\n if (taglibPath) {\n var taglib = taglibLoader.loadTaglibFromFile(taglibPath, true);\n addTaglib(taglib);\n }\n }\n });\n }\n\n for (let i = registeredTaglibs.length; i--; ) {\n addTaglib(registeredTaglibs[i]);\n }\n\n findCache[dirname] = { exclusiveTagDiscoveryDirs, taglibs };\n return taglibs;\n\n function addTaglib(taglib) {\n if (!added.has(taglib.id)) {\n added.add(taglib.id);\n taglibs.push(taglib);\n }\n }\n}\n\nfind._withMeta = function findWithMeta(\n dirname,\n registeredTaglibs,\n tagDiscoveryDirs,\n) {\n find(dirname, registeredTaglibs, tagDiscoveryDirs);\n return findCache[dirname];\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 taglibConfig.fs.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"
},
{
"path": "packages/compiler/src/taglib/index.js",
"content": "import markoModules from \"@marko/compiler/modules\";\nimport path from \"path\";\n\nimport tryLoadTranslator from \"../util/try-load-translator\";\nimport taglibConfig from \"./config\";\nimport finder from \"./finder\";\nimport loader from \"./loader\";\nimport Lookup from \"./lookup\";\n\nexport const excludeDir = finder.excludeDir;\nexport const excludePackage = finder.excludePackage;\n\nimport markoHTMLTaglib from \"./marko-html.json\";\nimport markoMathTaglib from \"./marko-math.json\";\nimport markoSVGTaglib from \"./marko-svg.json\";\n\nconst registeredTaglibs = [];\nconst loadedTranslatorsTaglibs = new Map();\nlet lookupCache = Object.create(null);\n\nregister(markoHTMLTaglib[\"taglib-id\"], markoHTMLTaglib);\nregister(markoSVGTaglib[\"taglib-id\"], markoSVGTaglib);\nregister(markoMathTaglib[\"taglib-id\"], markoMathTaglib);\n\nexport function buildLookup(dirname, requestedTranslator, onError) {\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 let taglibsForDir = loadedTranslatorsTaglibs.get(translator);\n let exclusiveTagDiscoveryDirs = undefined;\n\n if (!taglibsForDir) {\n loadedTranslatorsTaglibs.set(\n translator,\n (taglibsForDir = registeredTaglibs.concat(\n resolveOptionalTaglibs(translator.optionalTaglibs || [], onError)\n .concat(translator.taglibs)\n .map(([id, props]) => loadTaglib(id, props)),\n )),\n );\n }\n\n runAndCatchErrors(() => {\n const foundMeta = finder.find._withMeta(\n dirname,\n taglibsForDir,\n translator.tagDiscoveryDirs,\n );\n taglibsForDir = foundMeta.taglibs;\n exclusiveTagDiscoveryDirs = foundMeta.exclusiveTagDiscoveryDirs;\n }, onError);\n\n const cacheKey = taglibsForDir\n .map((it) => it.id)\n .sort()\n .join();\n let lookup = lookupCache[cacheKey];\n\n if (!lookup) {\n lookup = lookupCache[cacheKey] = new Lookup();\n lookup.exclusiveTagDiscoveryDirs = exclusiveTagDiscoveryDirs;\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 if (typeof props === \"undefined\") {\n [id, props] = resolveTaglib(id);\n }\n registeredTaglibs.push(loadTaglib(id, props));\n}\n\nexport function clearCaches() {\n loader.clearCache();\n finder.clearCache();\n lookupCache = Object.create(null);\n}\n\nexport function resolveOptionalTaglibs(taglibIds, onError) {\n const resolvedTaglibs = [];\n for (const id of taglibIds) {\n if (hasRootDependency(id)) {\n runAndCatchErrors(() => {\n resolvedTaglibs.push(resolveTaglib(id));\n }, onError);\n }\n }\n\n return resolvedTaglibs;\n}\n\n// Used by legacy compiler api.\nexport const _loader = loader;\nexport const _finder = finder;\n\nfunction runAndCatchErrors(fn, onError) {\n if (onError) {\n const prevOnError = taglibConfig.onError;\n taglibConfig.onError = onError;\n try {\n fn();\n } catch (err) {\n taglibConfig.onError(err);\n } finally {\n taglibConfig.onError = prevOnError;\n }\n } else {\n fn();\n }\n}\n\nfunction loadTaglib(id, props) {\n return loader.loadTaglibFromProps(loader.createTaglib(id), props);\n}\n\nfunction resolveTaglib(id) {\n switch (id[0]) {\n case \".\":\n case \"/\":\n case \"\\\\\":\n break;\n default:\n if (!id.endsWith(\".json\")) {\n id = path.join(id, \"marko.json\");\n }\n break;\n }\n\n const resolved = markoModules.resolve(id);\n return [resolved, markoModules.require(resolved)];\n}\n\nfunction hasRootDependency(id) {\n return !!(\n markoModules.pkg &&\n (markoModules.pkg.dependencies?.[id] ||\n markoModules.pkg.devDependencies?.[id])\n );\n}\n"
},
{
"path": "packages/compiler/src/taglib/loader/Attribute.js",
"content": "\"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"
},
{
"path": "packages/compiler/src/taglib/loader/DependencyChain.js",
"content": "\"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"
},
{
"path": "packages/compiler/src/taglib/loader/Property.js",
"content": "\"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"
},
{
"path": "packages/compiler/src/taglib/loader/Tag.js",
"content": "\"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"
},
{
"path": "packages/compiler/src/taglib/loader/Taglib.js",
"content": "\"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, isFromPackageJson) {\n ok(filePath, '\"filePath\" expected');\n this.filePath = this.path /* deprecated */ = this.id = filePath;\n this.isFromPackageJson = isFromPackageJson === true;\n this.dirname = path.dirname(this.filePath);\n this.scriptLang = undefined;\n this.tags = {};\n this.migrators = [];\n this.transformers = [];\n this.attributes = {};\n this.patternAttributes = [];\n this.imports = null;\n this.importsLookup = null;\n this.tagsDir = undefined;\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(\"Invalid attribute: \" + JSON.stringify(attribute));\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"
},
{
"path": "packages/compiler/src/taglib/loader/Transformer.js",
"content": "\"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"
},
{
"path": "packages/compiler/src/taglib/loader/cache.js",
"content": "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"
},
{
"path": "packages/compiler/src/taglib/loader/index.js",
"content": "var cache = require(\"./cache\");\n\nvar DependencyChain = require(\"./DependencyChain\");\nvar loaders = require(\"./loaders\");\nvar types = require(\"./types\");\n\nfunction loadTaglibFromProps(taglib, taglibProps) {\n return loaders.loadTaglibFromProps(taglib, taglibProps);\n}\n\nfunction loadTaglibFromFile(filePath, isFromPackageJson) {\n return loaders.loadTaglibFromFile(filePath, isFromPackageJson);\n}\n\nfunction loadTaglibFromDir(filePath, tagDiscoveryDir) {\n return loaders.loadTaglibFromDir(filePath, tagDiscoveryDir);\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.loadTaglibFromDir = loadTaglibFromDir;\nexports.loadTag = loadTag;\n"
},
{
"path": "packages/compiler/src/taglib/loader/json-file-reader.js",
"content": "var stripJsonComments = require(\"@luxass/strip-json-comments\").strip;\nvar taglibConfig = require(\"../config\");\nvar fsReadOptions = { encoding: \"utf8\" };\n\nexports.readFileSync = function (path) {\n var json = String(taglibConfig.fs.readFileSync(path, fsReadOptions));\n\n try {\n var taglibProps = JSON.parse(stripJsonComments(json));\n return taglibProps;\n } catch (cause) {\n throw new Error('Unable to parse JSON file at path \"' + path + '\".', {\n cause,\n });\n }\n};\n"
},
{
"path": "packages/compiler/src/taglib/loader/loadAttributeFromProps.js",
"content": "\"use strict\";\n\nvar assert = require(\"assert\");\nvar raptorRegexp = require(\"raptor-regexp\");\nvar createError = require(\"raptor-util/createError\");\nvar propertyHandlers = require(\"./property-handlers\");\nvar types = require(\"./types\");\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\": \"prefix-*\"\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"
},
{
"path": "packages/compiler/src/taglib/loader/loadAttributes.js",
"content": "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"
},
{
"path": "packages/compiler/src/taglib/loader/loadTagFromFile.js",
"content": "var ok = require(\"assert\").ok;\nvar cache = require(\"./cache\");\nvar jsonFileReader = require(\"./json-file-reader\");\nvar loaders = require(\"./loaders\");\nvar types = require(\"./types\");\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"
},
{
"path": "packages/compiler/src/taglib/loader/loadTagFromProps.js",
"content": "\"use strict\";\n\nvar ok = require(\"assert\").ok;\nvar nodePath = require(\"path\");\nvar createError = require(\"raptor-util/createError\");\nvar isObjectEmpty = require(\"raptor-util/isObjectEmpty\");\nvar markoModules = require(\"@marko/compiler/modules\");\nvar taglibConfig = require(\"../config\");\nvar loaders = require(\"./loaders\");\nvar propertyHandlers = require(\"./property-handlers\");\nvar types = require(\"./types\");\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nfunction resolveRelative(dirname, value) {\n return value[0] === \".\"\n ? markoModules.tryResolve(value, dirname) || value\n : value;\n}\n\nfunction resolveWithMarkoExt(dirname, value) {\n if (value[0] !== \".\") return value;\n\n if (\n markoModules.require.extensions &&\n !(\".marko\" in markoModules.require.extensions)\n ) {\n markoModules.require.extensions[\".marko\"] = undefined;\n try {\n return markoModules.tryResolve(value, dirname) || value;\n } finally {\n delete markoModules.require.extensions[\".marko\"];\n }\n }\n\n return markoModules.tryResolve(value, dirname) || 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 * \"\"\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 = resolveWithMarkoExt(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 taglibConfig.fs.statSync(path);\n tag.template = path;\n } catch (_) {\n // eslint-disable-next-line preserve-caught-error\n throw new Error('Template at path \"' + path + '\" does not exist.');\n }\n }\n\n /**\n * This property is used by @marko/language-tools (editor tooling)\n * to override the Marko file used when generating the tags exposed\n * typescript / jsdoc types.\n */\n types(value) {\n this.tag.types =\n value[0] === \".\" ? nodePath.resolve(this.dirname, value) : value;\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 tag.addAttribute(\n loaders.loadAttributeFromProps(\n nestedTag.targetProperty,\n { type: \"expression\" },\n dependencyChain,\n ),\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"
},
{
"path": "packages/compiler/src/taglib/loader/loadTaglibFromDir.js",
"content": "var ok = require(\"assert\").ok;\nvar nodePath = require(\"path\");\nvar cache = require(\"./cache\");\nvar DependencyChain = require(\"./DependencyChain\");\nvar scanTagsDir = require(\"./scanTagsDir\");\nvar types = require(\"./types\");\n\nfunction loadFromDir(dir, tagDiscoveryDir) {\n ok(dir, '\"dir\" is required');\n\n var componentsPath = nodePath.join(dir, tagDiscoveryDir);\n var taglib = cache.get(componentsPath);\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(componentsPath);\n cache.put(componentsPath, taglib);\n scanTagsDir(\n componentsPath,\n dir,\n tagDiscoveryDir,\n taglib,\n new DependencyChain([componentsPath]),\n );\n }\n\n return taglib;\n}\n\nmodule.exports = loadFromDir;\n"
},
{
"path": "packages/compiler/src/taglib/loader/loadTaglibFromFile.js",
"content": "var ok = require(\"assert\").ok;\nvar cache = require(\"./cache\");\nvar jsonFileReader = require(\"./json-file-reader\");\nvar loaders = require(\"./loaders\");\nvar types = require(\"./types\");\n\nfunction loadFromFile(filePath, isFromPackageJson) {\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, isFromPackageJson);\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"
},
{
"path": "packages/compiler/src/taglib/loader/loadTaglibFromProps.js",
"content": "\"use strict\";\n\nvar ok = require(\"assert\").ok;\nvar nodePath = require(\"path\");\nvar createError = require(\"raptor-util/createError\");\nvar markoModules = require(\"@marko/compiler/modules\");\nvar taglibFS = require(\"../config\");\nvar DependencyChain = require(\"./DependencyChain\");\nvar jsonFileReader = require(\"./json-file-reader\");\nvar loaders = require(\"./loaders\");\nvar propertyHandlers = require(\"./property-handlers\");\nvar scanTagsDir = require(\"./scanTagsDir\");\nvar types = require(\"./types\");\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nfunction resolveRelative(dirname, value) {\n return value[0] === \".\"\n ? markoModules.tryResolve(value, dirname) || value\n : 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 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 *\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 tag;\n\n if (typeof value === \"string\") {\n var tagFilePath = nodePath.resolve(this.dirname, value);\n\n try {\n taglibFS.fs.statSync(tagFilePath);\n } catch (_) {\n // eslint-disable-next-line preserve-caught-error\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 \"\"\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 // definitions.\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 scriptLang(lang) {\n // The \"script-lang\" property is used to specify the language of embedded scripts (either \"js\" or \"ts\").\n // The language tools will prefer the language specified by the \"script-lang\" if specified.\n // If unspecified the language tools will check for a tsconfig, if one is found then \"ts\", otherwise we use \"js\".\n this.taglib.scriptLang = lang;\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 exports(dir) {\n var taglib = this.taglib;\n var path = this.filePath;\n var dirname = this.dirname;\n\n if (taglib.isFromPackageJson || /[\\\\/]node_modules[\\\\/]/.test(path)) {\n taglib.tagsDir = false;\n\n scanTagsDir(\n path,\n dirname,\n dir,\n taglib,\n this.dependencyChain.append(`exports`),\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 = markoModules.tryResolve(curImport, dirname);\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 = markoModules.tryResolve(\n nodePath.join(dependencyName, \"marko.json\"),\n packageDir,\n );\n\n if (importPath) {\n taglib.addImport(importPath);\n }\n }\n }\n } else {\n importPath = markoModules.tryResolve(curImport, dirname);\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"
},
{
"path": "packages/compiler/src/taglib/loader/loaders.js",
"content": "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.loadTaglibFromDir = require(\"./loadTaglibFromDir\");\nexports.loadAttributes = require(\"./loadAttributes\");\nexports.isSupportedAttributeProperty = isSupportedAttributeProperty;\nexports.isSupportedTagProperty = isSupportedTagProperty;\n"
},
{
"path": "packages/compiler/src/taglib/loader/property-handlers.js",
"content": "\"use strict\";\n\nconst { hasOwnProperty } = Object.prototype;\nconst taglibConfig = require(\"../config\");\n\nfunction removeDashes(str) {\n return str.replace(/-([a-z])/g, function (match, lower) {\n return lower.toUpperCase();\n });\n}\n\nmodule.exports = function invokeHandlers(config, handlers, path) {\n function error(message, cause) {\n if (cause) {\n if (cause.__propertyHandlers) {\n throw cause;\n }\n\n message += \". Cause: \" + (cause.stack || cause);\n }\n\n if (path) {\n message += \" (\" + path + \")\";\n }\n\n var e = new Error(message);\n e.__propertyHandlers = true;\n taglibConfig.onError(e);\n }\n\n if (!config) {\n error('\"config\" argument is required');\n }\n\n if (typeof config !== \"object\") {\n error(\"object expected\");\n }\n\n for (var k in config) {\n if (hasOwnProperty.call(config, k)) {\n var value = config[k];\n var keyNoDashes = removeDashes(k);\n var handler = handlers[keyNoDashes];\n var isDefaultHandler = false;\n\n if (!handler) {\n handler = handlers[\"*\"];\n isDefaultHandler = true;\n }\n\n if (!handler) {\n var badProperty = JSON.stringify(k);\n if (k !== keyNoDashes) {\n badProperty += \"/\" + JSON.stringify(keyNoDashes);\n }\n error(\n \"Invalid option of \" +\n badProperty +\n \". Allowed: \" +\n Object.keys(handlers).join(\", \"),\n );\n }\n\n try {\n if (isDefaultHandler) {\n if (handler.call(handlers, k, value) === false) {\n error(\"Invalid option: \" + k);\n }\n } else {\n handler.call(handlers, value);\n }\n } catch (e) {\n error('Error while applying option of \"' + k + '\"', e);\n }\n }\n }\n\n if (handlers._end) {\n try {\n handlers._end();\n } catch (e) {\n error(\"Error after applying properties\", e);\n }\n }\n};\n"
},
{
"path": "packages/compiler/src/taglib/loader/scanTagsDir.js",
"content": "\"use strict\";\n\nconst nodePath = require(\"path\");\nconst taglibConfig = require(\"../config\");\nconst jsonFileReader = require(\"./json-file-reader\");\nconst loaders = require(\"./loaders\");\nconst types = require(\"./types\");\n\nconst tagFileTypes = [\n \"template\",\n \"renderer\",\n \"migrate\",\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: \"migrate\", type: \"migrate\" },\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 = taglibConfig.fs.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 (!taglibConfig.fs.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 = taglibConfig.fs.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;\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 taglibConfig.fs.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\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"
},
{
"path": "packages/compiler/src/taglib/loader/types.js",
"content": "exports.Taglib = require(\"./Taglib\");\nexports.Tag = require(\"./Tag\");\nexports.Attribute = require(\"./Attribute\");\nexports.Property = require(\"./Property\");\nexports.Transformer = require(\"./Transformer\");\n"
},
{
"path": "packages/compiler/src/taglib/lookup/index.js",
"content": "\"use strict\";\n\nvar nodePath = require(\"path\");\nvar ok = require(\"assert\").ok;\nvar extend = require(\"raptor-util/extend\");\nvar taglibTypes = require(\"../loader/types\");\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 if (sourceVal == null) continue;\n\n const targetVal = target[key];\n\n if (\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 this.exclusiveTagDiscoveryDirs = undefined;\n this.manualTagsDirs = 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 if (\n taglib.dirname &&\n typeof taglib.tagsDir === \"string\" &&\n /[/\\\\]tags[/\\\\]?$/.test(taglib.tagsDir)\n ) {\n (this.manualTagsDirs || (this.manualTagsDirs = new Set())).add(\n nodePath.resolve(taglib.dirname, taglib.tagsDir),\n );\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"
},
{
"path": "packages/compiler/src/taglib/marko-html.json",
"content": "{\n \"taglib-id\": \"marko-html\",\n \"\": {\n \"@download\": \"#html-download\",\n \"@href\": \"#html-href\",\n \"@hreflang\": \"#html-hreflang\",\n \"@media\": \"#html-media\",\n \"@ping\": \"#html-ping\",\n \"@referrerpolicy\": \"#html-referrerpolicy\",\n \"@rel\": \"#html-rel\",\n \"@target\": \"#html-target\",\n \"html\": true,\n \"autocomplete\": [\n {},\n {\n \"displayText\": \"a href=\\\"\\\"\",\n \"snippet\": \"a href=\\\"${1:https://}\\\"\"\n },\n {\n \"displayText\": \"a href=\\\"mailto:\\\"\",\n \"snippet\": \"a href=\\\"mailto:${1:joe@example.com}?subject=${2:feedback}\\\"\"\n }\n ],\n \"attribute-groups\": [\"html-attributes\"]\n },\n \"\": {\n \"html\": true,\n \"autocomplete\": [\n {},\n {\n \"snippet\": \"abbr title=\\\"$1\\\"\"\n }\n ],\n \"attribute-groups\": [\"html-attributes\"]\n },\n \"\": {\n \"html\": true,\n \"attribute-groups\": [\"html-attributes\"]\n },\n \"\": {\n \"html\": true,\n \"attribute-groups\": [\"html-attributes\"]\n },\n \"\": {\n \"html\": true,\n \"attribute-groups\": [\"html-attributes\"]\n },\n \"\": {\n \"@autoplay\": \"#html-autoplay\",\n \"@controls\": \"#html-controls\",\n \"@crossorigin\": \"#html-crossorigin\",\n \"@disableremoteplayback\": \"#html-disableremoteplayback\",\n \"@loop\": \"#html-loop\",\n \"@muted\": \"#html-muted\",\n \"@preload\": \"#html-preload\",\n \"@src\": \"#html-src\",\n \"html\": true,\n \"autocomplete\": [\n {},\n {\n \"snippet\": \"audio src=\\\"$1\\\"\"\n }\n ],\n \"attribute-groups\": [\"html-attributes\"]\n },\n \"\": {\n \"html\": true,\n \"attribute-groups\": [\"html-attributes\"]\n },\n \"\": {\n \"html\": true,\n \"attribute-groups\": [\"html-attributes\"]\n },\n \"\": {\n \"@dir\": \"#html-dir-for-bdo\",\n \"html\": true,\n \"autocomplete\": [\n {},\n {\n \"snippet\": \"bdo dir=\\\"${1:rtl}\\\"\"\n }\n ],\n \"attribute-groups\": [\"html-attributes\"]\n },\n \"\": {\n \"@cite\": \"#html-cite\",\n \"html\": true,\n \"autocomplete\": [\n {},\n {\n \"snippet\": \"blockquote cite=\\\"${1:https://}\\\"\"\n }\n ],\n \"attribute-groups\": [\"html-attributes\"]\n },\n \"\": {\n \"@onafterprint\": \"#html-onafterprint\",\n \"@onbeforeprint\": \"#html-onbeforeprint\",\n \"@onbeforeunload\": \"#html-onbeforeunload\",\n \"@onhashchange\": \"#html-onhashchange\",\n \"@onlanguagechange\": \"#html-onlanguagechange\",\n \"@onmessage\": \"#html-onmessage\",\n \"@onoffline\": \"#html-onoffline\",\n \"@ononline\": \"#html-ononline\",\n \"@onpagehide\": \"#html-onpagehide\",\n \"@onpageshow\": \"#html-onpageshow\",\n \"@onpopstate\": \"#html-onpopstate\",\n \"@onredo\": \"#html-onredo\",\n \"@onresize\": \"#html-onresize\",\n \"@onstorage\": \"#html-onstorage\",\n \"@onundo\": \"#html-onundo\",\n \"@onunload\": \"#html-onunload\",\n \"html\": true,\n \"attribute-groups\": [\"html-attributes\"]\n },\n \"\": {\n \"@autofocus\": \"#html-autofocus\",\n \"@disabled\": \"#html-disabled\",\n \"@form\": \"#html-form\",\n \"@formaction\": \"#html-formaction\",\n \"@formenctype\": \"#html-formenctype\",\n \"@formmethod\": \"#html-formmethod\",\n \"@formnovalidate\": \"#html-formnovalidate\",\n \"@formtarget\": \"#html-formtarget\",\n \"@name\": \"#html-name\",\n \"@type\": \"#html-type\",\n \"@value\": \"#html-value\",\n \"html\": true,\n \"autocomplete\": [\n {},\n {\n \"displayText\": \"button type=\\\"button\\\"\",\n \"snippet\": \"button type=\\\"${1:button}\\\"\"\n }\n ],\n \"attribute-groups\": [\"html-attributes\"]\n },\n \"\": {\n \"@height\": \"#html-height\",\n \"@width\": \"#html-width\",\n \"html\": true,\n \"autocomplete\": [\n {},\n {\n \"snippet\": \"canvas id=\\\"${1:canvas}\\\" width=\\\"${2:300}\\\" height=\\\"${3:300}\\\"\"\n }\n ],\n \"attribute-groups\": [\"html-attributes\"]\n },\n \"\": {\n \"html\": true,\n \"attribute-groups\": [\"html-attributes\"]\n },\n \"\": {\n \"html\": true,\n \"attribute-groups\": [\"html-attributes\"]\n },\n \"\": {\n \"html\": true,\n \"attribute-groups\": [\"html-attributes\"]\n },\n \"\": {\n \"@span\": \"#html-span\",\n \"html\": true,\n \"attribute-groups\": [\"html-attributes\"]\n },\n \"\": {\n \"html\": true,\n \"attribute-groups\": [\"html-attributes\"]\n },\n \"\": {\n \"html\": true,\n \"attribute-groups\": [\"html-attributes\"]\n },\n \"\": {\n \"@cite\": \"#html-cite\",\n \"@datetime\": \"#html-datetime\",\n \"html\": true,\n \"attribute-groups\": [\"html-attributes\"]\n },\n \"\": {\n \"@open\": \"#html-open\",\n \"html\": true,\n \"attribute-groups\": [\"html-attributes\"]\n },\n \"\": {\n \"html\": true,\n \"attribute-groups\": [\"html-attributes\"]\n },\n \"\": {\n \"html\": true,\n \"autocomplete\": [\n {},\n {\n \"snippet\": \"div class=\\\"$2\\\"\"\n }\n ],\n \"attribute-groups\": [\"html-attributes\"]\n },\n \"
\": {\n \"html\": true,\n \"attribute-groups\": [\"html-attributes\"]\n },\n \"\": {\n \"html\": true,\n \"attribute-groups\": [\"html-attributes\"]\n },\n \"\": {\n \"html\": true,\n \"attribute-groups\": [\"html-attributes\"]\n },\n \"\": {\n \"@height\": \"#html-height\",\n \"@src\": \"#html-src\",\n \"@type\": \"#html-type\",\n \"@width\": \"#html-width\",\n \"html\": true,\n \"autocomplete\": [\n {},\n {\n \"snippet\": \"embed type=\\\"${1:video/quicktime}\\\" src=\\\"${2:https://}\\\" width=\\\"${3:300}\\\" height=\\\"${4:300}\\\"\"\n }\n ],\n \"attribute-groups\": [\"html-attributes\"],\n \"parse-options\": {\n \"openTagOnly\": true\n }\n },\n \"\": {\n \"@disabled\": \"#html-disabled\",\n \"@form\": \"#html-form\",\n \"@name\": \"#html-name\",\n \"html\": true,\n \"attribute-groups\": [\"html-attributes\"]\n },\n \"\": {\n \"html\": true,\n \"attribute-groups\": [\"html-attributes\"]\n },\n \"\": {\n \"html\": true,\n \"attribute-groups\": [\"html-attributes\"]\n },\n \"\": {\n \"html\": true,\n \"attribute-groups\": [\"html-attributes\"]\n },\n \" \n \n
\n"
},
{
"path": "packages/runtime-class/test/components-browser/fixtures/component-renderToString/test.js",
"content": "var expect = require(\"chai\").expect;\n\nmodule.exports = function (helpers) {\n var component = helpers.mount(require.resolve(\"./index\"), {\n name: \"john\",\n });\n\n expect(component.renderedHtml).to.equal(\n '',\n );\n};\n"
},
{
"path": "packages/runtime-class/test/components-browser/fixtures/component-renderToString-callback-sync/component.js",
"content": "var helloComponent = require(\"./components/hello\").default;\n\nmodule.exports = {\n onMount: function () {\n // eslint-disable-next-line @typescript-eslint/no-this-alias\n var self = this;\n helloComponent.renderToString(\n {\n name: this.input.name,\n },\n function (error, html) {\n if (error) {\n self.emit(\"renderError\", error);\n } else {\n self.emit(\"html\", html);\n }\n },\n );\n },\n};\n"
},
{
"path": "packages/runtime-class/test/components-browser/fixtures/component-renderToString-callback-sync/components/hello/index.marko",
"content": "\n \n
\n"
},
{
"path": "packages/runtime-class/test/components-browser/fixtures/component-renderToString-callback-sync/components/test-async/renderer.js",
"content": "module.exports = function (input, out) {\n var asyncOut = out.beginAsync();\n setTimeout(function () {\n asyncOut.write(\"[async] \" + input.name);\n asyncOut.end();\n }, 10);\n};\n"
},
{
"path": "packages/runtime-class/test/components-browser/fixtures/component-renderToString-callback-sync/index.marko",
"content": "\n
\n
\n"
},
{
"path": "packages/runtime-class/test/components-browser/fixtures/component-renderToString-callback-sync/test.js",
"content": "var expect = require(\"chai\").expect;\n\nmodule.exports = function (helpers, done) {\n var component = helpers.mount(require.resolve(\"./index\"), {\n name: \"john\",\n });\n\n component.on(\"html\", function (renderedHtml) {\n expect(renderedHtml).to.equal(\"
[async] john
\");\n done();\n });\n\n component.on(\"error\", function (error) {\n done(error);\n });\n};\n"
},
{
"path": "packages/runtime-class/test/components-browser/fixtures/component-renderToString-text-node/component.js",
"content": "var myTextNodeComponent = require(\"./components/my-text-node\").default;\n\nmodule.exports = {\n onMount: function () {\n this.renderedHtml = myTextNodeComponent.renderToString();\n },\n};\n"
},
{
"path": "packages/runtime-class/test/components-browser/fixtures/component-renderToString-text-node/components/my-text-node.marko",
"content": "-- hello\n"
},
{
"path": "packages/runtime-class/test/components-browser/fixtures/component-renderToString-text-node/index.marko",
"content": "
\n"
},
{
"path": "packages/runtime-class/test/components-browser/fixtures/component-renderToString-text-node/test.js",
"content": "var expect = require(\"chai\").expect;\n\nmodule.exports = function (helpers) {\n var component = helpers.mount(require.resolve(\"./index\"));\n expect(component.renderedHtml).to.equal(\"hello\");\n};\n"
},
{
"path": "packages/runtime-class/test/components-browser/fixtures/component-replaceState/component.js",
"content": "module.exports = {\n onInput: function (input) {\n this.state = {\n heading: input.heading || \"\",\n message: input.message || \"\",\n colors: input.colors || [],\n };\n },\n};\n"
},
{
"path": "packages/runtime-class/test/components-browser/fixtures/component-replaceState/index.marko",
"content": "
\n
${state.heading} \n
\n ${state.message} \n \n \n "
},
{
"path": "packages/runtime-class/test/components-browser/fixtures/component-replaceState/test.js",
"content": "var expect = require(\"chai\").expect;\n\nmodule.exports = function (helpers) {\n var states = {\n original: {\n heading: \"original colors\",\n message: \"These are primary colors!\",\n colors: [\"red\", \"green\", \"blue\"],\n },\n new: {\n heading: \"new colors\",\n colors: [\"orange\", \"yellow\", \"purple\"],\n },\n };\n\n var component = helpers.mount(require.resolve(\"./index\"), states.original);\n\n expect(component.state.heading).to.equal(states.original.heading);\n expect(component.state.message).to.equal(states.original.message);\n expect(component.state.colors).to.deep.equal(states.original.colors);\n\n component.replaceState(states.new);\n component.update();\n\n expect(component.state.heading).to.equal(states.new.heading);\n expect(component.state.message).to.equal(states.new.message); // undefined\n expect(component.state.colors).to.deep.equal(states.new.colors);\n};\n"
},
{
"path": "packages/runtime-class/test/components-browser/fixtures/component-rerender-init-order/component.js",
"content": "module.exports = {\n onMount: function () {\n window.rerenderInitOrder.push(\"parent\");\n },\n onUpdate: function () {\n window.rerenderInitOrder.push(\"parent\");\n },\n};\n"
},
{
"path": "packages/runtime-class/test/components-browser/fixtures/component-rerender-init-order/components/app-rerender-init-order-child/component.js",
"content": "module.exports = {\n onMount: function () {\n // console.log(module.id, 'init()', this.state);\n window.rerenderInitOrder = window.rerenderInitOrder || [];\n window.rerenderInitOrder.push(this.input.id);\n },\n onUpdate: function () {\n // console.log(module.id, 'init()', this.state);\n window.rerenderInitOrder.push(this.input.id);\n },\n};\n"
},
{
"path": "packages/runtime-class/test/components-browser/fixtures/component-rerender-init-order/components/app-rerender-init-order-child/index.marko",
"content": "
\n [app-rerender-init-order-child] ${input.id}\n
"
},
{
"path": "packages/runtime-class/test/components-browser/fixtures/component-rerender-init-order/index.marko",
"content": "
\n [app-rerender-init-order]\n
\n \n "
},
{
"path": "packages/runtime-class/test/components-browser/fixtures/component-rerender-init-order/marko.json",
"content": "{\n \"tags-dir\": \"./components\"\n}\n"
},
{
"path": "packages/runtime-class/test/components-browser/fixtures/component-rerender-init-order/test.js",
"content": "var expect = require(\"chai\").expect;\n\nmodule.exports = function (helpers) {\n var component = helpers.mount(require.resolve(\"./index\"), {\n version: 0,\n });\n\n expect(window.rerenderInitOrder).to.deep.equal([\n \"childB\",\n \"childA\",\n \"parent\",\n ]);\n\n window.rerenderInitOrder = [];\n\n component.input = { version: 1 };\n component.update();\n\n // console.log('ACTUAL ORDER: ', window.rerenderInitOrder);\n expect(window.rerenderInitOrder).to.deep.equal([\n \"childB\",\n \"childA\",\n \"parent\",\n ]);\n\n window.rerenderInitOrder = null;\n};\n"
},
{
"path": "packages/runtime-class/test/components-browser/fixtures/component-rerender-reuse-stateful/components/hello/index.marko",
"content": "class {\n onMount() {\n window.helloInstances = window.helloInstances || [];\n window.helloInstances.push(this);\n }\n\n onInput(input) {\n this.state = {\n name: input.name\n }\n }\n}\n\n
Hello ${state.name} \n \n \n
"
},
{
"path": "packages/runtime-class/test/components-browser/fixtures/component-rerender-reuse-stateful/marko.json",
"content": "{\n \"tags-dir\": \"./components\"\n}\n"
},
{
"path": "packages/runtime-class/test/components-browser/fixtures/component-rerender-reuse-stateful/test.js",
"content": "var expect = require(\"chai\").expect;\n\nmodule.exports = function (helpers) {\n var component = helpers.mount(require.resolve(\"./index\"), {});\n\n expect(window.helloInstances.length).to.equal(2);\n\n var helloEls = component.getEl(\"root\").querySelectorAll(\".hello\");\n expect(helloEls[0].innerHTML).to.equal(\"Hello Jane\");\n expect(helloEls[1].innerHTML).to.equal(\"Hello John0\");\n\n var hello1 = component.getComponent(\"hello1\");\n var hello2 = component.getComponent(\"hello2\");\n\n component.state.count++;\n component.update();\n\n // Make sure no more instances of the nested components were created\n expect(window.helloInstances.length).to.equal(2);\n\n // Make sure the UI components received the new state as part of onInput()\n expect(hello1.state.name).to.equal(\"Jane\");\n expect(hello2.state.name).to.equal(\"John1\");\n\n // Make sure the HTML elements were reused\n var helloElsAfter = component.getEl(\"root\").querySelectorAll(\".hello\");\n expect(helloElsAfter[0]).to.equal(helloEls[0]);\n expect(helloElsAfter[1]).to.equal(helloEls[1]);\n\n // Make sure the DOM was updated\n expect(helloElsAfter[0].innerHTML).to.equal(\"Hello Jane\");\n expect(helloElsAfter[1].innerHTML).to.equal(\"Hello John1\");\n\n window.helloInstances = undefined;\n};\n"
},
{
"path": "packages/runtime-class/test/components-browser/fixtures/component-rerender-stateless-new-props/component.js",
"content": "module.exports = {};\n"
},
{
"path": "packages/runtime-class/test/components-browser/fixtures/component-rerender-stateless-new-props/index.marko",
"content": "\n\tHello ${input.name}! You have ${input.messageCount} new messages.\n\t
foo
\n
![](\"https://user-images.githubusercontent.com/1958812/37050480-d53e4276-2128-11e8-8c7a-f5d842956c98.png\"/)
) to start debugging. Learn more about [debugging node](https://www.youtube.com/watch?v=Xb_0awoShR8&t=103s) from this video.\n\n```\nnpm test -- --grep=test-name --inspect-brk\n```\n\nIn addition to [setting breakpoints](https://developers.google.com/web/tools/chrome-devtools/javascript/breakpoints), you can also add [`debugger;`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/debugger) statements in both your JavaScript files and Marko templates:\n\n```marko\n$ debugger;\n