diff options
Diffstat (limited to 'shared.8f4eb7b8be92849ae2cc.js.map')
| -rw-r--r-- | shared.8f4eb7b8be92849ae2cc.js.map | 1 |
1 files changed, 0 insertions, 1 deletions
diff --git a/shared.8f4eb7b8be92849ae2cc.js.map b/shared.8f4eb7b8be92849ae2cc.js.map deleted file mode 100644 index b64773f..0000000 --- a/shared.8f4eb7b8be92849ae2cc.js.map +++ /dev/null @@ -1 +0,0 @@ -{"version":3,"file":"shared.8f4eb7b8be92849ae2cc.js","mappings":"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","sources":["webpack:///../api/packages/devicetree/index.js","webpack:///../api/packages/devicetree/lib/formatters.js","webpack:///../api/packages/devicetree/lib/helpers/index.js","webpack:///../api/packages/devicetree/lib/helpers/nodes.js","webpack:///../api/packages/devicetree/lib/helpers/properties.js","webpack:///../api/packages/devicetree/lib/helpers/trees.js","webpack:///../api/packages/devicetree/lib/helpers/values.js","webpack:///../api/packages/devicetree/lib/node-collection.js","webpack:///../api/packages/devicetree/lib/parser.js","webpack:///../api/packages/keymap-editor-zmk-backend/lib/apply-keymap-changes.js","webpack:///../api/packages/keymap-editor-zmk-backend/lib/devicetree/bindings.js","webpack:///../api/packages/keymap-editor-zmk-backend/lib/devicetree/collections/behaviors.js","webpack:///../api/packages/keymap-editor-zmk-backend/lib/devicetree/collections/combos.js","webpack:///../api/packages/keymap-editor-zmk-backend/lib/devicetree/collections/layers.js","webpack:///../api/packages/keymap-editor-zmk-backend/lib/devicetree/collections/macros.js","webpack:///../api/packages/keymap-editor-zmk-backend/lib/devicetree/keymap-document.js","webpack:///../api/packages/keymap-editor-zmk-backend/lib/devicetree/sanity-checks.js","webpack:///../api/packages/keymap-editor-zmk-backend/lib/extract-keymap-data.js","webpack:///../api/packages/keymap-editor-zmk-backend/lib/keymap.js","webpack:///../api/packages/keymap-layout-tools/lib/render.js","webpack:///../api/packages/string-utils/index.js","webpack:///../api/packages/zmk-data/behaviors.js","webpack:///../api/packages/zmk-data/keycode-mappings.js","webpack:///../api/packages/zmk-data/keycodes.js","webpack:///../api/packages/zmk-data/parameters.js"],"sourcesContent":["module.exports = require('./lib/parser')\n","const {\n removeStartingWhitespace,\n removeTrailingWhitespace,\n reindent,\n dedent\n} = require('string-utils')\nconst { getLabeledItem, getNodeLabels } = require('./helpers/nodes')\n\nconst DEFAULT_INDENT = ' '\nconst DEFAULT_MULTILINE_INTEGER_CELLS_INDENT = 'keep'\n\nfunction isMultilineNode (node) {\n return node.text.indexOf('\\n') !== -1\n}\n\nfunction isMultilinePropertyNode (node) {\n return node?.type === 'property' && (\n node.namedChildren.length > 2 ||\n node.namedChildren.slice(1).some(isMultilineNode)\n )\n}\n\nfunction isInlineComment (node) {\n return (\n node.type === 'comment' &&\n node.previousSibling &&\n // Nodes for pre-processor directives include trailing newline characters.\n // For simplicity, a preproc cannot have an inline comment.\n node.previousSibling.type !== 'preproc_def' &&\n node.previousSibling.type !== 'preproc_function_def' &&\n node.previousSibling.type !== 'preproc_include' &&\n node.previousSibling.endPosition.row === node.startPosition.row\n )\n}\n\nfunction getNodeIndentation (node, tab) {\n return tab.repeat(getNodeDepth(node))\n}\n\nfunction getModelineConfiguration (tree) {\n return tree.rootNode.namedChildren.reduce((config, node) => {\n if (node.type === 'comment') {\n const contents = node.text.startsWith('//')\n ? node.text.slice(2).trim()\n : node.text.slice(2, -2).trim()\n\n for (const line of contents.split('\\n')) {\n const match = line.match(/dt-formatter:\\s*(\\w+)\\s*=\\s*(.+)$/)\n if (match) {\n const [key, jsonValue] = match.slice(1)\n try {\n const value = JSON.parse(jsonValue)\n config[key] = value\n } catch {}\n }\n }\n }\n\n return config\n }, {})\n}\n\n/**\n * Determine the depth of the node in the device tree\n *\n * A depth of 0 is anything at the document level -- this includes the \"/\" node\n *\n * @param {SyntaxNode} node any kind of syntax node\n * @returns {Integer} depth\n */\nfunction getNodeDepth (node) {\n let n = node\n let depth = 0\n const stop = node.tree.rootNode\n\n while ((n = n.parent) && n && n.id !== stop.id) {\n if (n.type !== 'labeled_item') {\n depth++\n }\n }\n\n return depth\n}\n\nfunction shouldIncludeBlank (nodeA, nodeB) {\n if (!nodeB) {\n return false\n }\n\n const sameType = nodeA.type === nodeB.type\n const isAdjacentDeviceTreeNode = sameType && nodeA.type === 'node'\n\n // TODO: this should probably just not insert whitespace around comments\n return (\n isAdjacentDeviceTreeNode ||\n isMultilinePropertyNode(nodeA) ||\n (!sameType && !isInlineComment(nodeB))\n )\n}\n\n/**\n * Apply formatting (indentation and whitespace) to a node and its descendents\n *\n * Indentation is based on the node's depth in the full tree (not just relative\n * to the supplied `node` parameter) and currently limited to 4-space tabs.\n *\n * The existing formatting of `integer_cells` nodes (ie, `bindings = <...>;`) is\n * considered sacred and 0 levels of indentation will be applied to those lines.\n * @param {SyntaxNode} node any node in the devicetree\n * @returns {String} the newly-formatted text for the syntax node\n */\nfunction formatNode (node, options = {}) {\n const { indent = DEFAULT_INDENT } = options\n\n if (node.type === 'labeled_item') {\n node = getLabeledItem(node)\n }\n\n const [identifier, ...children] = node.namedChildren\n const indentation = getNodeIndentation(node, indent)\n\n function formatChildren (children) {\n return children.reduce((lines, childNode, i, arr) => {\n // Merge inline comments onto the previous node's line.\n // This feels a bit hacky but it must be performed on the \"unformatted\"\n // comment syntax node (this check is also happening when the previous\n // node is being formatted and the extra blank line is being considered).\n if (isInlineComment(childNode)) {\n lines[lines.length - 1] += childNode.text\n return lines\n }\n lines.push(...formatNode(childNode, options))\n\n if (shouldIncludeBlank(childNode, children[i + 1])) {\n lines.push('')\n }\n\n return lines\n }, [])\n }\n\n switch (node.type) {\n case 'document':\n return [...formatChildren(node.namedChildren), '']\n\n case 'node':\n return [\n indentation + `${formatLabels(getNodeLabels(node))}${identifier.text}${getAddress(node)} {`,\n ...formatChildren(hasAddress(node) ? node.namedChildren.slice(2) : children),\n indentation + '};'\n ]\n\n case 'property':\n return formatPropertyNode(node, options)\n\n case 'preproc_include':\n case 'preproc_def':\n case 'preproc_function_def':\n return [node.text.trimEnd()]\n\n default:\n // this is mainly for things I didn't expect to see, but also includes\n // commonly used features like preproc_includes that technically work when\n // used inside nodes but aren't recognized by the grammar at the moment.\n // See: https://github.com/joelspadin/tree-sitter-devicetree/issues/1\n return [indentation + node.text]\n }\n}\n\nfunction hasAddress (node) {\n return !!node.childForFieldName('address')\n}\n\nfunction getAddress (node) {\n return hasAddress(node)\n // note address field doesn't give the actual value yet\n ? `@${node.namedChildren[1].text}`\n : ''\n}\n\nfunction formatLabels (labels) {\n return labels.map(text => `${text}: `).join('')\n}\n\nfunction formatPropertyNode (node, options = {}) {\n const {\n indent = DEFAULT_INDENT,\n multilineIntegerCellsIndent = DEFAULT_MULTILINE_INTEGER_CELLS_INDENT\n } = options\n\n const [identifier, ...children] = node.namedChildren\n const indentation = getNodeIndentation(node, indent)\n\n const noValue = children.length === 0\n const simpleValue = children.length === 1 && !isMultilineNode(children[0])\n const singleIntegerCell = children.length === 1 && children[0].type === 'integer_cells'\n const labels = formatLabels(getNodeLabels(node))\n\n // TODO: get smarter about different property value types\n if (noValue) return [indentation + node.text]\n\n if (simpleValue) {\n return [indentation + `${labels}${identifier.text} = ${children[0].text};`]\n } else if (singleIntegerCell) {\n let bindingsLines = removeStartingWhitespace(\n removeTrailingWhitespace(\n children[0].text.slice(1, -2)\n )\n )\n\n switch (multilineIntegerCellsIndent) {\n case 'reindent':\n bindingsLines = reindent(bindingsLines, indentation + indent)\n break\n\n case 'dedent':\n bindingsLines = dedent(bindingsLines)\n break\n\n case 'keep':\n default:\n break\n }\n\n return [\n indentation + `${labels}${identifier.text} = <`,\n ...bindingsLines.split('\\n'),\n indentation + '>;'\n ]\n }\n\n return [\n indentation + `${identifier.text} =`,\n ...[].concat(...children.map(node => formatNode(node, options)))\n .map((line, i, arr) => {\n const suffix = i === arr.length - 1 ? ';' : ','\n return [line, suffix].join('')\n })\n ]\n}\n\nmodule.exports = {\n formatNode,\n getModelineConfiguration,\n getNodeDepth,\n isInlineComment,\n shouldIncludeBlank\n}\n","module.exports = Object.assign(\n {},\n require('./nodes'),\n require('./properties'),\n require('./trees'),\n require('./values')\n)\n","const assert = require('assert')\nconst reverse = require('lodash/reverse')\n\n/**\n * Check if an ordered list of nodes are consecutive\n * Nodes are consecutive if each node is adjacent to the next, so that no other\n * sibling nodes exist between them.\n * @param {Array<SyntaxNode>} nodes\n * @returns {Boolean}\n */\nfunction nodesAreConsecutive (nodes) {\n return nodes.every((node, i) => (\n i < nodes.length - 1\n ? node.nextSibling.id === nodes[i + 1].id\n : true\n ))\n}\n\n/**\n * Get the string value of each reference label attached to the given node.\n * Labels are in in descending order of depth.\n * @param {SyntaxNode} node\n * @returns {Array<String>}\n */\nfunction getNodeLabels (node) {\n return getNodeLabelNodes(node).map(label => label.text)\n}\n\n// blech\nfunction getNodeLabelNodes (node) {\n return getNodeChildrenByFieldName(node.parent, 'label')\n}\n\n/**\n * Descend into a chain of labeled_item nodes to get at the actual item\n * @param {SyntaxNode} labeledItemNode syntax node for a devicetree label\n * @returns {SyntaxNode}\n */\nfunction getLabeledItem (labeledItemNode) {\n assert(labeledItemNode.type === 'labeled_item')\n return labeledItemNode.childForFieldName('item')\n}\n\nfunction getNodeChildrenByFieldName (node, fieldName) {\n const children = []\n\n // Iteration is done with a cursor here because only TreeCursor will directly\n // tell us what field is associated with the current node. The node itself\n // will not tell us about its own field, and Node.childForFieldName(field)\n // will only tell us about a single child with the specified field.\n const cursor = node.walk()\n cursor.gotoFirstChild()\n\n do {\n const isNamed = cursor.currentNode().isNamed()\n const isField = cursor.currentFieldName() === fieldName\n if (isNamed && isField) {\n children.push(cursor.currentNode())\n }\n } while (cursor.gotoNextSibling())\n\n cursor.delete()\n\n return children\n}\n\n/**\n * Find a single child of the given node with a matching identifier\n * @param {SyntaxNode} node\n * @param {Function|String} nameOrMatch\n * @returns {SyntaxNode}\n */\nfunction findChildrenByIdentifier (node, nameOrMatch) {\n const match = typeof nameOrMatch === 'string'\n ? text => text === nameOrMatch\n : nameOrMatch\n\n return node.namedChildren.filter(node => (\n node.type === 'node' &&\n node.children.find(sub => (\n sub.type === 'identifier' &&\n match(sub.text)\n ))\n ))\n}\n\n/**\n * Find a child of the given node(s) with a matching name.\n * If multiple nodes are given to search through, they will be searched in\n * reverse order so that the \"latest\" instance of a node takes precedence.\n * @param {Array<SyntaxNode>|SyntaxNode} nodes\n * @param {RegExp|String} nameOrMatch\n */\nfunction findChildByIdentifier (nodes, nameOrMatch) {\n nodes = [].concat(nodes)\n for (const node of reverse(nodes)) {\n const match = findChildrenByIdentifier(node, nameOrMatch)[0]\n if (match) {\n return match\n }\n }\n}\n\nfunction listNodes (nodes, opts = {}) {\n const { stripNewlines = true, limit = 50 } = opts\n for (const node of nodes) {\n let value = node.text\n if (stripNewlines) value = value.replace(/\\n/g, '')\n if (limit) value = value.slice(0, limit)\n\n console.log(node.id, `[${node.type}]`, '->', value)\n }\n}\n\nmodule.exports = {\n nodesAreConsecutive,\n getNodeLabels,\n getNodeLabelNodes,\n getLabeledItem,\n getNodeChildrenByFieldName,\n findChildByIdentifier,\n findChildrenByIdentifier,\n listNodes\n}\n","const { getNodeChildrenByFieldName } = require('./nodes')\nconst {\n parseStringLiteral,\n parseIntegerCells,\n parseIntegerArray,\n parsePhandles,\n parsePhandle,\n parsePhandleArray,\n parseIntegerUnion,\n serializeIntValue,\n serializeArrayValue\n} = require('./values')\n\n/** @typedef {{ parsed: any, raw: string, useRaw?: boolean }} PropertyValue */\n/** @typedef {Object.<string, PropertyValue>} Properties */\n\n/**\n * Get a property with the given name in this node, if it exists.\n * @param {SyntaxNode} node\n * @param {String} propertyName\n * @returns {SyntaxNode|undefined}\n */\nfunction findNodeProperty (node, propertyName) {\n return node.children.find(node => (\n node.type === 'property' &&\n node.children[0].text === propertyName\n ))\n}\n\nfunction getPropertyNode (node, propertyName) {\n return node.namedChildren.find(child => (\n child.type === 'property' &&\n child.childForFieldName('name')?.text === propertyName\n ))\n}\n\nfunction getProperty (node, property) {\n const propertyNode = node.children.find(node => (\n node.type === 'property' &&\n node.children[0].text === property\n ))\n\n return propertyNode && {\n syntaxNode: propertyNode,\n name: property,\n value: propertyNode.children[2]?.text\n }\n}\n\nfunction getPropertyValue (node, property) {\n property = typeof property === 'string'\n ? getPropertyNode(node, property)\n : property\n\n return property?.childForFieldName('value')\n}\n\nfunction getPropertyValues (node, property) {\n const propertyNode = getPropertyNode(node, property)\n return propertyNode && getNodeChildrenByFieldName(propertyNode, 'value')\n}\n\n/**\n * @param {SyntaxNode} node devicetree node from which to extract property values\n * @param {Object} schema devicetree schema of a spcecific node\n * @return {Properties} properties\n */\nfunction parsePropertiesFromSchema (node, schema) {\n return Object.keys(schema).reduce((properties, prop) => {\n const propSchema = schema[prop]\n const values = parsePropertyFromSchema(node, prop, propSchema)\n\n if (values !== undefined) {\n properties[prop] = {\n parsed: values\n }\n }\n\n return properties\n }, {})\n}\n\n/**\n * @param {SyntaxNode} node devicetree node from which to extract a property value\n * @param {String} property name of property\n * @param {Object} schema devicetree schema of specific property\n */\nfunction parsePropertyFromSchema (node, property, schema) {\n const propertyNode = findNodeProperty(node, property)\n const values = getPropertyValues(node, property)\n\n switch (schema.type) {\n case 'string':\n return parseStringLiteral(values?.[0])\n\n case 'boolean':\n return !!propertyNode\n\n case 'int':\n return parseIntegerCells(values)?.[0]\n\n case 'array':\n return parseIntegerArray(values)\n\n case 'phandle':\n return parsePhandle(values)\n\n case 'phandles':\n return parsePhandles(values)\n\n case 'phandle-array':\n return parsePhandleArray(values)\n\n case 'integer-union':\n return parseIntegerUnion(values)\n }\n}\n\nfunction serializePropertyFromSchema (property, schema) {\n // TODO: Probably make separate functions?\n switch (schema.type) {\n case 'string':\n return `\"${property.parsed}\"`\n\n case 'boolean':\n // This is a weird case because instead of an explicit value we use the\n // presense of the property (name) to indicate true or false. Note that\n // this will get more complicated when supporting the `/delete-property/`\n // flag (?)\n return property.parsed\n\n case 'int':\n return serializeIntValue(property.parsed)\n\n case 'array':\n return serializeArrayValue(property.parsed)\n\n case 'phandle':\n return property.parsed.map(phandle => `<${phandle}>`).join(', ')\n\n case 'phandles':\n case 'phandle-array':\n // TODO: Grouping binding cells into separate phandle-arrays shouldn't\n // be the default behavior but right now the only place this would be\n // unacceptably weird is the bindings property for layer and macro nodes\n // which already do their own formatting explicitly.\n return property.parsed\n .reduce((bindings, node) => {\n if (node.startsWith('&')) {\n bindings.push([node])\n } else {\n const last = bindings[bindings.length - 1]\n last.push(node)\n }\n\n return bindings\n }, [])\n .map(group => `<${group.join(' ')}>`)\n .join(', ')\n\n case 'integer-union':\n return `<(${property.parsed.map(v => v.toString()).join('|')})>`\n }\n}\n\nmodule.exports = {\n findNodeProperty,\n getProperty,\n getPropertyNode,\n getPropertyValue,\n getPropertyValues,\n parsePropertiesFromSchema,\n parsePropertyFromSchema,\n serializePropertyFromSchema\n}\n","\n/**\n *\n * @param {Tree|Node} tree Starting point for breadth-first traversal\n * @param {Object} [options={}]\n * @param {Integer} [options.maxDepth=-1]\n * @returns {Function} get next node, or undefined when traversal is complete\n */\nfunction BreadthFirstIterator (tree, options = {}) {\n const { maxDepth = -1 } = options\n const queue = [{ depth: 0, node: tree.rootNode || tree }]\n\n return function next () {\n const current = queue.shift()\n if (current && (maxDepth === -1 || current.depth < maxDepth)) {\n queue.push(...current.node.namedChildren.map(node => ({\n node, depth: current.depth + 1\n })))\n }\n return current?.node\n }\n}\n\n/**\n *\n * @param {Tree|Node} tree Starting point for depth-first traversal\n * @param {Object} [options={}]\n * @param {Integer} [options.maxDepth=-1]\n * @returns {Function} get next node, or undefined when traversal is complete\n */\nfunction DepthFirstIterator (tree, options = {}) {\n const { maxDepth = -1 } = options\n const stack = [{ depth: 0, node: tree.rootNode || tree }]\n\n return function next () {\n const current = stack.shift()\n if (current && (maxDepth === -1 || current.depth < maxDepth)) {\n stack.unshift(...current.node.namedChildren.map(node => ({\n node, depth: current.depth + 1\n })))\n }\n return current?.node\n }\n}\n\n/**\n * Find nodes in `tree` that satisfy the given `predicate` function.\n *\n * @param {Tree|SyntaxNode} tree\n * @param {Function} predicate\n * @param {Object} [options={}]\n * @param {Boolean} [options.single=false]\n * @param {Integer} [options.maxDepth=-1]\n * @param {Boolean} [options.depthFirst=false]\n * @returns {Array<SyntaxNode>|SyntaxNode} use options.single to return only the first matching node\n */\nfunction searchTree (tree, predicate, options = {}) {\n const {\n single = false,\n maxDepth = -1,\n depthFirst = false\n } = options\n\n const iter = depthFirst\n ? DepthFirstIterator(tree, { maxDepth })\n : BreadthFirstIterator(tree, { maxDepth })\n\n const matches = []\n let node\n\n while ((node = iter())) {\n if (predicate(node)) {\n if (single) {\n return node\n }\n\n matches.push(node)\n }\n }\n\n if (single) {\n return undefined\n }\n\n return matches\n}\n\nfunction findNodeByIdentifier (tree, name) {\n return searchTree(tree, node => (\n node.type === 'node' &&\n node.childForFieldName('name').text === name\n ), { single: true })\n}\n\nfunction findLabeledItem (tree, name) {\n let node = searchTree(tree, node => (\n node.type === 'labeled_item' &&\n node.children[0].type === 'identifier' &&\n node.children[0].text === name\n ), { single: true })\n\n if (!node) {\n return null\n }\n\n do {\n node = node.childForFieldName('item')\n } while (node.type === 'labeled_item')\n\n return node\n}\n\nfunction createPredicateForCompatible (compatible) {\n let match\n\n if (compatible instanceof RegExp) {\n match = text => compatible.test(text)\n } else if (typeof compatible === 'string') {\n match = text => text === `\"${compatible}\"`\n } else if (typeof compatible === 'function') {\n match = compatible\n } else {\n throw new TypeError('Unexpected type ' + typeof compatible)\n }\n\n return node => (\n node.type === 'property' &&\n node.childForFieldName('name').text === 'compatible' &&\n match(node.childForFieldName('value').text)\n )\n}\n\n/**\n * Find single node including a `compatible` property with the given value.\n *\n * @param {Tree|SyntaxNode} tree\n * @param {String|RegExp|Function} compatible\n * @returns {SyntaxNode|undefined}\n */\nfunction findNodeWithCompatible (tree, compatible) {\n // TODO: look into tree sitter queries again, doing these searches within web\n // assembly is probably much faster. Alternatively, performing this lookup as\n // a breadth-first search would likely save a lot of time since we're often\n // expecting to match nodes just inside the devicetree root node. It may also\n // be worth refining the depth-first search to avoid going deeper in some\n // situations -- if I'm matching a property string it doesn't make sense to\n // recurse into the property values.\n const predicate = createPredicateForCompatible(compatible)\n const propertyNode = searchTree(tree, predicate, { single: true })\n\n return propertyNode?.parent\n}\n/**\n * Find descendent nodes including a `compatible` property with the given value.\n *\n * @param {Tree|SyntaxNode} tree\n * @param {String|RegExp|Function} compatible\n * @returns {Array<SyntaxNode>}\n */\nfunction findNodesWithCompatible (tree, compatible) {\n const predicate = createPredicateForCompatible(compatible)\n return searchTree(tree, predicate).map(property => property.parent)\n}\n\nmodule.exports = {\n BreadthFirstIterator,\n DepthFirstIterator,\n searchTree,\n findLabeledItem,\n findNodeByIdentifier,\n findNodeWithCompatible,\n findNodesWithCompatible\n}\n","const { searchTree } = require('./trees')\n\nconst isNegativeInteger = node => (\n node.type === 'unary_expression' &&\n node.childForFieldName('operator').type === '-' &&\n node.childForFieldName('argument').type === 'integer_literal'\n)\n\nconst isNumberishType = node => (\n ['identifier', 'integer_literal'].includes(node.type) || isNegativeInteger(node)\n)\n\nconst isBindingType = node => (\n // call_expression node includes modifier functions like `LC(A)`\n ['identifier', 'integer_literal', 'reference', 'call_expression'].includes(node.type)\n)\n\nconst isBindingRef = node => node.type === 'reference'\n\nconst extractInteger = node => (\n node.type === 'integer_literal' || isNegativeInteger(node)\n ? Number(node.text)\n : node.text\n)\n\nfunction parseStringLiteral (value) {\n return value?.text?.slice(1, -1)\n}\n\nfunction parseIntegerCells (values) {\n return parseIntegerArray(values)\n}\n\nfunction parseIntegerArray (values) {\n return values?.flatMap(cells => (\n cells.namedChildren\n .filter(isNumberishType)\n .map(extractInteger)\n ))\n}\n\nfunction parsePhandle (values) {\n return parsePhandles(values)[0]\n}\n\nfunction parsePhandles (values) {\n return values?.flatMap(cells => (\n cells.namedChildren\n .filter(isBindingRef)\n .map(value => value.text)\n ))\n}\n\nfunction parsePhandleArray (values) {\n return values?.flatMap(cells => (\n cells.namedChildren\n .filter(isBindingType)\n .map(value => value.text)\n ))\n}\n\nfunction parseIntegerUnion (values) {\n return values?.flatMap(value => (\n searchTree(value, isNumberishType, { depthFirst: true })\n )).map(extractInteger)\n}\n\nfunction sanitizeIdentifier (name) {\n return name\n .replace(/[^a-zA-Z0-9,._+-]/g, '_')\n .slice(0, 31)\n}\n\nfunction serializeIntegerCell (value) {\n value = value.toString()\n if (value.match(/-\\d+/)) {\n value = `(${value})`\n }\n\n return value\n}\n\nfunction serializeIntValue (value) {\n return `<${serializeIntegerCell(value)}>`\n}\n\nfunction serializeArrayValue (values) {\n return `<${values.map(serializeIntegerCell).join(' ')}>`\n}\n\nmodule.exports = {\n parseStringLiteral,\n parseIntegerCells,\n parseIntegerArray,\n parsePhandle,\n parsePhandleArray,\n parsePhandles,\n parseIntegerUnion,\n sanitizeIdentifier,\n serializeIntValue,\n serializeArrayValue\n}\n","const assert = require('assert')\nconst { ReferenceError } = assert\nconst difference = require('lodash/difference')\nconst filter = require('lodash/filter')\nconst isEqual = require('lodash/isEqual')\nconst map = require('lodash/map')\nconst partition = require('lodash/partition')\nconst reverse = require('lodash/reverse')\n\nconst { getNodeLabels, getLabeledItem } = require('./helpers/nodes')\nconst { getPropertyValues } = require('./helpers/properties')\nconst { sanitizeIdentifier } = require('./helpers/values')\n\nclass NodeCollection {\n managedProperties = []\n _cached_container_node = null\n _cached_container_tree_version = 0\n _cached_collection_nodes = null\n _cached_collection_tree_version = 0\n\n constructor (document, options = {}) {\n this.document = document\n if (options.managedProperties) { this.managedProperties = options.managedProperties }\n if (options.lookupContainerNode) { this.lookupContainerNode = options.lookupContainerNode.bind(this) }\n if (options.injectContainerNode) { this.injectContainerNode = options.injectContainerNode.bind(this) }\n if (options.lookupNodes) { this.lookupNodes = options.lookupNodes.bind(this) }\n if (options.injectNode) { this.injectNode = options.injectNode.bind(this) }\n }\n\n lookupContainerNode () { throw new ReferenceError('Provide `lookupContainerNode` in constructor or override this method') }\n injectContainerNode () { throw new ReferenceError('Provide `injectContainerNode` in constructor or override this method') }\n\n lookupNodes () { throw new ReferenceError('Provide `lookupNodes` in constructor or override this method') }\n injectNode () { throw new ReferenceError('Provide `injectNode` in constructor or override this method') }\n\n get container () {\n if (this._cached_container_tree_version !== this.document._parse_version) {\n delete this._cached_container_node\n }\n if (!this._cached_container_node) {\n this._cached_container_node = this.lookupContainerNode(this.document)\n this._cached_container_tree_version = this.document._parse_version\n }\n\n return this._cached_container_node\n }\n\n get nodes () {\n if (this._cached_collection_tree_version !== this.document._parse_version) {\n delete this._cached_collection_nodes\n }\n if (!this._cached_collection_nodes) {\n this._cached_collection_nodes = this.lookupNodes(this.document)\n this._cached_collection_tree_version = this.document._parse_version\n }\n\n return this._cached_collection_nodes\n }\n\n updateCollection (collection) {\n if (collection.length && !this.container) {\n this.injectContainerNode(this)\n this.document.flushChanges()\n }\n\n const originalIndices = [...this.nodes.keys()]\n const reusedIndices = filter(map(collection, 'index'), index => this.nodes[index])\n const removedIndices = difference(originalIndices, reusedIndices)\n const [updates, additions] = partition(collection, node => this.nodes[node.index])\n\n for (const node of updates) {\n this.updateNode(node.index, node)\n }\n\n for (const index of reverse(removedIndices)) {\n this.document.removeNode(this.nodes[index])\n }\n\n for (const node of additions) {\n this.injectNode(this, node)\n this.document.flushChanges()\n this.updateNode(this.nodes.length - 1, node)\n }\n }\n\n /**\n * Update an existing devicetree node\n * @param {Integer} index the position of the existing node to update\n * @param {Object} update the new node state to apply to devicetree\n * @param {String} update.name the devicetree node name\n * @param {Array<String>} update.labels zero or more devictree labels to apply to the node\n * @param {Object} update.properties mapping of property name to (serialized) property values\n */\n updateNode (index, update) {\n const existing = this.extractNode(this.nodes[index])\n this.updateNodeName(index, update, existing)\n this.updateNodeLabels(index, update, existing)\n this.updateNodeProperties(index, update, existing)\n this.cleanupNodeProperties(index, update, existing)\n }\n\n updateNodeName (index, update, existing) {\n if (existing.name !== update.name) {\n const identifier = this.nodes[index].childForFieldName('name')\n this.document.replaceNode(identifier, sanitizeIdentifier(update.name), {\n removeStartingWhitespace: false\n })\n }\n }\n\n updateNodeLabels (index, update, existing) {\n if (!isEqual(existing.labels, update.labels)) {\n this.document.replaceNodeLabels(this.nodes[index], update.labels)\n }\n }\n\n updateNodeProperties (index, update, existing) {\n const { properties } = update\n\n for (const name in properties) {\n const values = properties[name]\n\n if (!isEqual(values, existing.properties[name])) {\n this.document.setProperty(\n this.nodes[index],\n name,\n values\n )\n }\n }\n }\n\n cleanupNodeProperties (index, update, existing) {\n const { properties } = update\n for (const name of this.managedProperties) {\n if (name in existing.properties && !(name in properties)) {\n this.document.deleteProperty(this.nodes[index], name)\n }\n }\n }\n\n /**\n * Extract basic information from a devicetree node for convenience.\n * The output of this function is an object with structure:\n * {\n * name: String,\n * labels: Array<String>\n * properties: Object<name:values>\n * }\n * This can be overridden to include additional details.\n * @param {SyntaxNode} node a devicetree node from which to extract info\n * @returns {Object}\n */\n extractNode (node) {\n // TODO: should there be a `Node` class?\n // TODO: Should there be a `PropertyCollection` with similar abstractions?\n assert(node.type === 'node')\n\n const name = node.childForFieldName('name').text\n const labels = getNodeLabels(node)\n const properties = node.namedChildren.reduce((acc, child) => {\n if (child.type === 'labeled_item') {\n child = getLabeledItem(child)\n }\n if (child.type === 'property') {\n const name = child.childForFieldName('name').text\n const values = getPropertyValues(node, name)\n const parsed = map(values, 'text')\n const raw = parsed.join(', ')\n acc[name] = { parsed, raw }\n }\n\n return acc\n }, {})\n\n return {\n name,\n labels,\n properties\n }\n }\n\n /**\n * Evaluate each node with `extractNode` and include an `index` property\n * @returns {Array<Object>}\n */\n extractCollection () {\n return this.nodes.map((node, index) => ({\n index, ...this.extractNode(node)\n }))\n }\n}\n\nmodule.exports = {\n NodeCollection\n}\n","const assert = require('assert')\nconst { sortBy } = require('lodash')\n\nconst TreeSitter = require('web-tree-sitter')\n\nconst { getPosition } = require('string-utils')\nconst { getNodeLabelNodes } = require('./helpers/nodes')\nconst { getProperty } = require('./helpers/properties')\n\nlet _parser\n\nasync function getParser () {\n if (!_parser) {\n await TreeSitter.init()\n const language = await TreeSitter.Language.load(\n\n // This is meant to make loading possible in a browser.\n global.window\n ? require('../data/tree-sitter-devicetree.wasm')\n : __dirname + '/../data/tree-sitter-devicetree.wasm'\n )\n _parser = new TreeSitter()\n _parser.setLanguage(language)\n }\n\n return _parser\n}\n\nclass DevicetreeDocument {\n constructor (parser, text) {\n this.parser = parser\n this._parse_version = 0\n this._enableChangeBuffering = false\n this._bufferedChanges = []\n this.update(text)\n }\n\n cleanup () {\n this.tree.delete()\n }\n\n update (text, inputEdit = null) {\n if (inputEdit && this.tree && this._enableChangeBuffering) {\n const replacementText = text.slice(inputEdit.startIndex, inputEdit.newEndIndex)\n this._bufferedChanges.push({\n startIndex: inputEdit.startIndex,\n update: inputEdit,\n replacementText\n })\n } else {\n this.text = text\n this._reparse()\n }\n }\n\n _reparse () {\n this.tree && this.tree.delete()\n this.tree = this.parser.parse(this.text)\n this._parse_version++\n }\n\n flushChanges () {\n if (this._bufferedChanges.length === 0) {\n return\n }\n\n const updates = sortBy(this._bufferedChanges, 'startIndex')\n\n // console.log('flushing updates', updates)\n // console.log({ original: this.text })\n\n const chunks = updates.reduce((chunks, { update, replacementText }, i) => {\n const nextUpdate = updates[i + 1]\n const prevEnd = i > 0\n ? updates[i - 1].update.oldEndIndex\n : 0\n\n const preChunk = this.text.slice(prevEnd, update.startIndex)\n const chunk = replacementText\n chunks.push(preChunk)\n chunks.push(chunk)\n\n // console.log({\n // preChunk,\n // chunk\n // })\n\n if (!nextUpdate) {\n // console.log('selecting final cunk', {\n // original: this.text,\n // update,\n // postChunk: this.text.slice(update.oldEndIndex)\n // })\n chunks.push(this.text.slice(update.oldEndIndex))\n }\n\n return chunks\n }, [])\n\n // console.log('generated chunks', chunks)\n\n this.text = chunks.join('')\n // console.log('generated text', this.text)\n this._reparse()\n this._bufferedChanges = []\n }\n\n removeNode (node) {\n this.replaceNode(node, '')\n }\n\n /**\n * Replace the contents of a syntax node with other (serialized) content.\n *\n * @param {SyntaxNode} node the node to be replaced\n * @param {String} newContent the devicetree source replacing the original node\n * @param {Object} options\n * @param {Bool} options.removeStartingWhitespace whether to attempt to start replacing at the start of `node`'s line\n */\n replaceNode (node, newContent, options = {}) {\n const { removeStartingWhitespace = true } = options\n const { text: documentText } = this\n\n // TODO: this all should probably go\n const precedingNewline = documentText.lastIndexOf('\\n', node.startIndex)\n const hasStartingWhitespace = precedingNewline !== -1 && documentText.slice(precedingNewline + 1, node.startIndex).match(/\\s+/)\n const start = hasStartingWhitespace && removeStartingWhitespace\n ? precedingNewline\n : node.startIndex\n\n const replacement = [\n documentText.slice(0, start),\n newContent,\n documentText.slice(node.endIndex)\n ].join('')\n\n const inputEdit = {\n startIndex: start,\n startPosition: getPosition(newContent, start),\n oldEndIndex: node.endIndex,\n oldEndPosition: node.endPosition,\n newEndIndex: start + newContent.length,\n newEndPosition: getPosition(replacement, start + newContent.length)\n }\n\n this.update(replacement, inputEdit)\n }\n\n replaceRange (startIndex, skipToIndex, newContent) {\n const { text: source } = this\n const pre = source.slice(0, startIndex)\n const post = source.slice(skipToIndex)\n const replacement = [pre, newContent, post].join('')\n const newEndIndex = startIndex + newContent.length\n const inputEdit = {\n startIndex,\n startPosition: getPosition(source, startIndex),\n oldEndIndex: skipToIndex,\n oldEndPosition: getPosition(source, skipToIndex),\n newEndIndex,\n newEndPosition: getPosition(replacement, newEndIndex)\n }\n\n return this.update(replacement, inputEdit)\n }\n\n /**\n * Replace any existing labels attached to the specified node.\n * @param {SyntaxNode} labeledNode\n * @param {Array<String>} newLabels\n */\n replaceNodeLabels (labeledNode, newLabels) {\n const labelNodes = getNodeLabelNodes(labeledNode)\n const sorted = sortBy(labelNodes, 'startIndex')\n const serializedLabels = newLabels.map(label => `${label}:`).join(' ')\n const start = (sorted[0] && sorted[0].parent) || labeledNode\n\n this.replaceRange(start.startIndex, labeledNode.startIndex, serializedLabels)\n }\n\n /**\n * Insert text content before a specified node\n * @param {SyntaxNode} node the node before which to insert\n * @param {String} newContent the new devicetree source to be inserted\n */\n insertTextBeforeNode (node, newContent) {\n this.replaceRange(node.startIndex, node.startIndex, newContent)\n }\n\n /**\n * Insert text content after a specified node\n * @param {SyntaxNode} node the node after which to insert\n * @param {String} newContent the new devicetree source to be inserted\n */\n insertTextAfterNode (node, newContent) {\n this.replaceRange(node.endIndex, node.endIndex, newContent)\n }\n\n /**\n * Append devicetree source to the specified node\n * @param {SyntaxNode} parentNode parent node in which to add content\n * @param {*} newContent the new devicetree source to be inserted\n */\n addChildNode (parentNode, newContent) {\n assert(parentNode.type === 'node')\n\n const closingBrace = parentNode.children.find(node => node.type === '}')\n return this.replaceRange(\n closingBrace.startIndex,\n closingBrace.startIndex,\n newContent\n )\n }\n\n /**\n * Set/create a property with the specified value in the specified node\n * @param {SyntaxNode} node target node in which to set property\n * @param {String} property name of property to set\n * @param {String|Boolean} value serialized devicetree value.\n */\n setProperty (node, property, value) {\n const existing = getProperty(node, property)\n\n if (typeof value === 'boolean' && !value) {\n if (existing) {\n this.deleteProperty(node, property)\n }\n\n return\n }\n\n const newText = value.length\n ? `${property} = ${value};`\n : `${property};`\n\n if (existing) {\n return this.replaceNode(\n existing.syntaxNode,\n newText,\n { removeStartingWhitespace: false }\n )\n }\n\n return this.addChildNode(node, `\\n ${newText}`)\n }\n\n /**\n * Remove a property from a specified devicetree node.\n * @param {SyntaxNode} node where to search for the named property\n * @param {String} property name of property to remove\n */\n deleteProperty (node, property) {\n const existing = getProperty(node, property)\n if (existing) {\n this.replaceNode(existing.syntaxNode, '')\n }\n }\n}\n\nmodule.exports = {\n getParser,\n DevicetreeDocument\n}\n","const flatten = require('lodash/flatten')\nconst get = require('lodash/get')\nconst keyBy = require('lodash/keyBy')\nconst map = require('lodash/map')\nconst uniq = require('lodash/uniq')\n\nconst { getParser } = require('devicetree')\nconst { formatNode, getModelineConfiguration } = require('devicetree/lib/formatters')\nconst { behaviorBindings } = require('zmk-data/behaviors')\n\nconst KeymapDocument = require('./devicetree/keymap-document')\nconst { encodeKeymap } = require('./keymap')\n\nconst behavioursByBind = keyBy(behaviorBindings, 'code')\n\nasync function applyKeymapChanges (layout, keymap, original, featureFlags = {}) {\n // TODO: generate this higher up in the call stack, I don't think we need the\n // original keymap object anymore except for the `layer_names` property\n const encoded = encodeKeymap(layout, keymap)\n const behaviourHeaders = flatten(getBehavioursUsed(keymap).map(\n bind => get(behavioursByBind, [bind, 'includes'], [])\n ))\n\n const devicetreeKeymap = new KeymapDocument(await getParser(), original)\n devicetreeKeymap._enableChangeBuffering = true\n devicetreeKeymap.mergeUpdated(encoded, featureFlags)\n devicetreeKeymap.replaceBehaviourIncludes(behaviourHeaders)\n devicetreeKeymap.flushChanges()\n\n try {\n const config = getModelineConfiguration(devicetreeKeymap.tree)\n return formatNode(devicetreeKeymap.tree.rootNode, config).join('\\n')\n } catch (err) {\n console.error('Failed to format devictree', err)\n return devicetreeKeymap.text\n } finally {\n devicetreeKeymap.cleanup()\n }\n}\n\nfunction getBehavioursUsed (keymap) {\n const keybinds = flatten(map(keymap.layers, layer => layer.properties?.bindings?.parsed || layer.bindings))\n const comboBinds = flatten(map(keymap.combos, 'bindings'))\n const macroBinds = flatten(map(keymap.macros, 'properties.bindings.parsed'))\n\n return uniq(map([\n ...keybinds,\n ...comboBinds,\n ...macroBinds\n ], 'value'))\n}\n\nmodule.exports = applyKeymapChanges\n","const filter = require('lodash/filter')\nconst get = require('lodash/get')\nconst { parsePropertyFromSchema } = require('devicetree/lib/helpers/properties')\n\n/** @typedef {String} IntegerCell */\n/** @typedef {String} Bind */\n/** @typedef {{ value: String, params: Array<BindValue> }} BindValue */\n\n/**\n * @param {SyntaxNode} node\n * @param {String} [propertyName='bindings']\n * @returns {Array<Bind>|undefined} bind strings\n */\nfunction parseBindings (node, propertyName = 'bindings') {\n const bindings = parsePropertyFromSchema(node, propertyName, {\n type: 'phandle-array'\n })\n\n return bindings\n ? groupPhandleArrayBindings([].concat(...bindings))\n : undefined\n}\n\n/**\n * @param {Array<IntegerCell>} bindingCells\n * @returns {Array<Bind>}\n */\nfunction groupPhandleArrayBindings (bindingCells) {\n return bindingCells.reduce((bindings, node) => {\n if (node.startsWith('&')) {\n bindings.push([node])\n } else {\n const last = bindings[bindings.length - 1]\n last.push(node)\n }\n\n return bindings\n }, []).map(binding => binding.join(' '))\n}\n\nconst MACRO_CONTROL_BEHAVIOURS = [\n '¯o_tap',\n '¯o_press',\n '¯o_release',\n '¯o_tap_time',\n '¯o_wait_time',\n '¯o_pause_for_release'\n]\n\n/**\n * Group a flat list of bind strings at macro activation mode change\n * @param {Array<Bind>} bindings\n * @returns {Array<Array<Bind>>}\n */\nfunction groupMacroBindings (bindings) {\n return bindings.reduce((rows, binding, i, arr) => {\n const behaviourBind = binding.split(' ')[0]\n\n if (MACRO_CONTROL_BEHAVIOURS.includes(behaviourBind)) {\n if (rows.at(-1).length > 0) {\n rows.push([])\n }\n\n rows.at(-1).push(binding)\n if (i < arr.length - 1) {\n rows.push([])\n }\n } else {\n rows.at(-1).push(binding)\n }\n\n return rows\n }, [[]])\n}\n\n/**\n * Parse a bind string into a tree of values and parameters\n * @param {Bind} binding\n * @returns {BindValue}\n */\nfunction parseKeyBinding (binding, keymap) {\n const paramsPattern = /\\((.+)\\)/\n\n function parse (code) {\n const value = code.replace(paramsPattern, '')\n const params = get(code.match(paramsPattern), '[1]', '').split(',')\n .map(s => s.trim())\n .filter(s => s.length > 0)\n .map(parse)\n\n return {\n // TODO: some defines (e.g., in bat43) can involve multiple bind values\n // this replacement should happen before the bindings array is parsed\n value: get(keymap.defines, value, value),\n params\n }\n }\n\n const value = binding.match(/^(&.+?)\\b/)[1]\n const params = filter(binding.replace(/^&.+?\\b\\s*/, '')\n .split(' '))\n .map(parse)\n\n return { value, params }\n}\n\n/**\n * Serialize a node of a BindValue tree\n * @param {BindValue} parsed\n * @returns {Bind}\n */\nfunction encodeBindValue (parsed) {\n const params = (parsed.params || []).map(encodeBindValue)\n const paramString = params.length > 0 ? `(${params.join(',')})` : ''\n return parsed.value + paramString\n}\n\n/**\n * Serialize a top-level BindValue object\n * @param {BindValue} parsed\n * @returns {Bind}\n */\nfunction encodeKeyBinding (parsed) {\n const { value, params } = parsed\n\n return `${value} ${params.map(encodeBindValue).join(' ')}`.trim()\n}\n\nmodule.exports = {\n parseBindings,\n parseKeyBinding,\n groupMacroBindings,\n groupPhandleArrayBindings,\n encodeKeyBinding\n}\n","const isEqual = require('lodash/isEqual')\n\nconst {\n findChildByIdentifier,\n findChildrenByIdentifier,\n findNodesWithCompatible,\n findNodeProperty,\n getPropertyValues,\n parsePropertyFromSchema,\n sanitizeIdentifier,\n serializePropertyFromSchema\n} = require('devicetree/lib/helpers')\nconst { NodeCollection } = require('devicetree/lib/node-collection')\nconst { behaviorSchemas } = require('zmk-data/behaviors')\n\nconst { parseKeyBinding, encodeKeyBinding } = require('../bindings')\n\nfunction resolveBehaviorBindings (behavior) {\n const bindingsValues = getPropertyValues(behavior, 'bindings') || []\n const bindings = bindingsValues.flatMap(bindingsValue => (\n bindingsValue.namedChildren.flatMap(bindCode => bindCode.text)\n ))\n\n return { bindings }\n}\n\nclass BehaviorCollection extends NodeCollection {\n lookupContainerNode () {\n const rootNodes = findChildrenByIdentifier(this.document.tree.rootNode, '/')\n return findChildByIdentifier(rootNodes, 'behaviors')\n }\n\n injectContainerNode () {\n const keymap = findNodesWithCompatible(this.document.tree.rootNode, 'zmk,keymap').at(-1)\n this.document.insertTextBeforeNode(keymap, '\\nbehaviors {};\\n')\n }\n\n lookupNodes () {\n return findNodesWithCompatible(this.document.tree.rootNode, value => (\n value.startsWith('\"zmk,behavior-') &&\n value !== '\"zmk,behavior-macro\"'\n ))\n }\n\n injectNode (_, behavior) {\n const name = sanitizeIdentifier(behavior.name)\n const last = this.nodes.at(-1)\n const nodeContent = `${behavior.labels[0]}: ${name} {\n compatible = ${behavior.properties.compatible.raw};\n };`\n\n // new node will be updated with full set of properties later, but for now\n // a known behavior has to be set to make sure this node is not filtered out\n if (last) {\n this.document.insertTextAfterNode(last, nodeContent)\n } else {\n this.document.addChildNode(this.container, nodeContent)\n }\n }\n\n extractNode (node) {\n const compatible = findNodeProperty(node, 'compatible')?.namedChildren[1].text.slice(1, -1)\n\n const schema = behaviorSchemas[compatible]\n const extracted = super.extractNode(node)\n const { name: identifier, labels } = extracted\n\n extracted.properties.compatible.parsed = compatible\n\n if (schema) {\n for (const prop in schema.properties) {\n const propSchema = schema.properties[prop]\n const extractedProp = extracted.properties[prop]\n if (extractedProp) {\n extractedProp.parsed = parsePropertyFromSchema(node, prop, propSchema)\n\n if (propSchema.type === 'phandle-array') {\n const bindStrings = extractedProp.parsed\n .reduce((bindings, node) => {\n if (node.startsWith('&')) {\n bindings.push([node])\n } else {\n const last = bindings[bindings.length - 1]\n last.push(node)\n }\n\n return bindings\n }, [])\n .map(group => group.join(' '))\n\n extractedProp.parsed = bindStrings.map(bind => parseKeyBinding(bind, {}))\n }\n }\n }\n }\n\n const bindingCells = extracted.properties['#binding-cells']?.parsed || 0\n const label = extracted.properties.label?.parsed\n\n return Object.assign(\n extracted,\n { binding: `&${labels[0]}` },\n { code: `&${labels[0]}` },\n { aliases: labels.map(label => `&${label}`) },\n { identifier },\n { bindingCells },\n label && { label },\n compatible && { compatible },\n\n resolveBehaviorBindings(node)\n )\n }\n\n legacyParseNodes () {\n return this.nodes.map(node => this.extractNode(node))\n }\n\n updateNodeProperties (index, update, existing) {\n const { properties } = update\n const compatible = findNodeProperty(this.nodes[index], 'compatible')?.namedChildren[1].text.slice(1, -1)\n const schema = behaviorSchemas[compatible]\n\n for (const name in properties) {\n const prop = properties[name]\n const propSchema = schema?.properties?.[name]\n\n if (!isEqual(prop, existing.properties[name])) {\n const serialized = propSchema && !prop.useRaw\n ? (\n // Not ideal to have this type-check here, but our handling of this\n // type goes beyond devicetree.\n propSchema.type !== 'phandle-array'\n ? serializePropertyFromSchema(prop, propSchema)\n : prop.parsed\n .map(binding => encodeKeyBinding(binding))\n .map(bindString => `<${bindString}>`)\n .join(', ')\n )\n : prop.raw\n\n this.document.setProperty(this.nodes[index], name, serialized)\n }\n }\n }\n\n cleanupNodeProperties (index, update, existing) {\n for (const prop in existing.properties) {\n if (!(prop in update.properties)) {\n this.document.deleteProperty(this.nodes[index], prop)\n }\n }\n }\n}\n\nmodule.exports = BehaviorCollection\n","const isEqual = require('lodash/isEqual')\n\nconst {\n findNodeWithCompatible,\n findNodesWithCompatible,\n getLabeledItem,\n getNodeLabels,\n parsePropertiesFromSchema,\n serializePropertyFromSchema\n} = require('devicetree/lib/helpers')\nconst { NodeCollection } = require('devicetree/lib/node-collection')\n\nconst { groupPhandleArrayBindings, parseKeyBinding, encodeKeyBinding } = require('../bindings')\n\n// TODO: extract the `zmk,combos` schema and handle the `childProperties` prop\nconst comboSchema = {\n bindings: { type: 'phandle-array' },\n 'key-positions': { type: 'array' },\n 'timeout-ms': { type: 'int' },\n 'slow-release': { type: 'boolean' },\n layers: { type: 'array' }\n}\n\nclass ComboCollection extends NodeCollection {\n managedProperties = [\n 'bindings',\n 'key-positions',\n 'timeout-ms',\n 'layers',\n 'slow-release'\n ]\n\n lookupContainerNode () {\n return findNodeWithCompatible(this.document.tree.rootNode, 'zmk,combos')\n }\n\n injectContainerNode () {\n // TODO: this sucks and is making many other things worse.\n // I've encountered keymap files that specify multiple root devicetree nodes\n // which ZMK accepts and merges together, and multiple keymap nodes which\n // devicetree accepts and selects the last one.\n // Working around this is a pain in the ass and is hurting performance so\n // the best thing to do is stop supporting this and present a warning to the\n // user explaining why their keymap isn't being parsed as expected.\n const keymap = findNodesWithCompatible(this.document.tree.rootNode, 'zmk,keymap').at(-1)\n this.document.insertTextBeforeNode(keymap, `\n combos {\n compatible = \"zmk,combos\";\n };\n `)\n }\n\n lookupNodes () {\n if (!this.container) {\n return []\n }\n\n return this.container.namedChildren.reduce((nodes, syntaxNode) => {\n if (syntaxNode.type === 'labeled_item') {\n syntaxNode = getLabeledItem(syntaxNode)\n }\n if (syntaxNode.type === 'node') {\n nodes.push(syntaxNode)\n }\n\n return nodes\n }, [])\n }\n\n injectNode (_, combo) {\n const name = combo.name.replace(/[^a-zA-Z0-9_]/g, '_')\n const last = this.nodes.at(-1)\n const nodeContent = `${name} {};`\n\n if (last) {\n this.document.insertTextAfterNode(last, nodeContent)\n } else {\n this.document.addChildNode(this.container, nodeContent)\n }\n }\n\n updateNodeProperties (index, update, existing) {\n const { properties } = update\n for (const name in properties) {\n const prop = properties[name]\n const propSchema = comboSchema[name]\n\n if (!isEqual(prop, existing.properties[name])) {\n const serialized = propSchema && !prop.useRaw\n ? (\n // Not ideal to have this type-check here, but our handling of this\n // type goes beyond devicetree.\n propSchema.type !== 'phandle-array'\n ? serializePropertyFromSchema(prop, propSchema)\n : prop.parsed\n .map(binding => encodeKeyBinding(binding))\n .map(bindString => `<${bindString}>`)\n .join(', ')\n )\n : prop.raw\n\n this.document.setProperty(this.nodes[index], name, serialized)\n }\n }\n\n if (!update.properties.layers) {\n this.document.deleteProperty(this.nodes[index], 'layers')\n }\n }\n\n extractNode (node) {\n const name = node.childForFieldName('name').text\n const labels = getNodeLabels(node)\n const properties = parsePropertiesFromSchema(node, comboSchema)\n\n if (properties.bindings) {\n properties.bindings.parsed = (\n groupPhandleArrayBindings(properties.bindings.parsed)\n .map(parseKeyBinding)\n )\n }\n\n return { name, labels, properties }\n }\n\n legacyParse (node) {\n const { name, labels, properties } = this.extractNode(node)\n const legacyNode = {\n name,\n labels,\n properties,\n identifier: name\n }\n\n const legacyMapping = {\n bindings: 'bindings',\n 'timeout-ms': 'timeoutMs',\n 'key-positions': 'keyPositions',\n 'slow-release': 'slowRelease',\n layers: 'layers'\n }\n\n for (const prop of Object.keys(legacyMapping)) {\n if (properties[prop]) {\n legacyNode[legacyMapping[prop]] = properties[prop].parsed\n }\n }\n\n if (legacyNode.layers?.length === 0 || isEqual(legacyNode.layers, [-1])) {\n delete legacyNode.layers\n }\n\n return legacyNode\n }\n\n legacyParseNodes () {\n return this.nodes.map(node => this.legacyParse(node))\n }\n}\n\nmodule.exports = ComboCollection\n","const difference = require('lodash/difference')\nconst filter = require('lodash/filter')\nconst isEqual = require('lodash/isEqual')\nconst map = require('lodash/map')\n\nconst {\n findChildrenByIdentifier,\n findNodesWithCompatible,\n getLabeledItem,\n getNodeLabels,\n parsePropertiesFromSchema,\n serializePropertyFromSchema\n} = require('devicetree/lib/helpers')\nconst { NodeCollection } = require('devicetree/lib/node-collection')\n\nconst { groupPhandleArrayBindings, parseKeyBinding, encodeKeyBinding } = require('../bindings')\n\nfunction isSorted (array) {\n return array.every((value, i, arr) => (\n i === arr.length - 1 ||\n arr[i] < arr[i + 1]\n ))\n}\n\n// TODO: extract the `zmk,keymap` schema and handle the `childProperties` prop\nconst layerSchema = {\n label: {\n type: 'string'\n },\n bindings: {\n type: 'phandle-array'\n },\n 'sensor-bindings': {\n type: 'phandle-array'\n }\n}\n\nclass LayerCollection extends NodeCollection {\n managedProperties = [\n 'label',\n 'bindings',\n 'sensor-bindings'\n ]\n\n lookupContainerNode () {\n return findNodesWithCompatible(this.document.tree.rootNode, 'zmk,keymap').at(-1)\n }\n\n injectContainerNode () {\n const rootNodes = findChildrenByIdentifier(this.document.tree.rootNode, '/')\n this.document.addChildNode(\n rootNodes.at(-1),\n '\\nkeymap { compatible = \"zmk,keymap\"; };\\n'\n )\n }\n\n lookupNodes () {\n if (!this.container) {\n return []\n }\n\n return this.container.namedChildren.reduce((nodes, syntaxNode) => {\n if (syntaxNode.type === 'labeled_item') {\n syntaxNode = getLabeledItem(syntaxNode)\n }\n if (syntaxNode.type === 'node') {\n nodes.push(syntaxNode)\n }\n\n return nodes\n }, [])\n }\n\n injectNode (_, layer) {\n const last = this.nodes.at(-1)\n const name = (layer.name || 'new_layer').replace(/[^a-zA-Z0-9_]/g, '_')\n const nodeContent = `${name} {};`\n\n if (last) {\n this.document.insertTextAfterNode(last, nodeContent)\n } else {\n this.document.addChildNode(this.container, nodeContent)\n }\n }\n\n updateCollection (collection) {\n const originalIndices = [...this.nodes.keys()]\n\n super.updateCollection(collection)\n this.updateLayerPositions(collection, originalIndices)\n }\n\n /**\n * Sort layer nodes according to the updates array ordering.\n * This could perhaps be implemented generically in NodeCollection or even in\n * DevicetreeDocument but that's complicated, especially considering scenarios\n * like BehaviorCollection and MacroCollection which may be dealing with nodes\n * that are subsets of a single nodes children, or even nodes that aren't even\n * children of the same parent.\n *\n * For now it only makes sense for layer nodes to be sortable, so here you go.\n *\n * @param {Array<Object>} updates same argument passed to updateCollection\n * @param {Array<Integer>} originalIndices node indices from before updates were applied\n */\n updateLayerPositions (updates, originalIndices) {\n const reusedIndices = filter(map(updates, 'index'), index => this.nodes[index])\n const removedIndices = difference(originalIndices, reusedIndices)\n const positionMap = [...originalIndices]\n\n // Add new nodes to the end of the position map. Their current position does\n // not matter because they're already sorted relative to eachother and the\n // mapping will let us reorder everything at the end.\n for (const index in updates) {\n const update = updates[index]\n const nextIndex = positionMap.length\n if (update.index === undefined || !originalIndices.includes(update.index)) {\n update.index = nextIndex\n positionMap[nextIndex] = nextIndex\n }\n }\n\n // Shift every mapped position for nodes following removed nodes.\n for (let i = removedIndices.length - 1; i >= 0; --i) {\n const index = removedIndices[i]\n positionMap[index] = null\n for (let j = index + 1; j < positionMap.length; j++) {\n if (positionMap[j] !== null) {\n positionMap[j] -= 1\n }\n }\n }\n\n const targetIndexOrder = map(updates, 'index')\n if (targetIndexOrder.length > 0 && !isSorted(targetIndexOrder)) {\n this.document.flushChanges()\n this.document.replaceRange(\n this.nodes[0].startIndex,\n this.nodes.at(-1).endIndex,\n targetIndexOrder\n .map(index => positionMap[index])\n .map(index => this.nodes[index].text)\n .join('\\n')\n )\n }\n }\n\n updateNodeProperties (index, update, existing) {\n const { properties } = update\n for (const name in properties) {\n const prop = properties[name]\n const propSchema = layerSchema[name]\n\n if (!isEqual(prop, existing.properties[name])) {\n const serialized = propSchema && !prop.useRaw\n ? (\n // Not ideal to have this type-check here, but our handling of this\n // type goes beyond devicetree.\n propSchema.type !== 'phandle-array'\n ? serializePropertyFromSchema(prop, propSchema)\n : prop.parsed\n .map(binding => encodeKeyBinding(binding))\n .map(bindString => `<${bindString}>`)\n .join(', ')\n )\n : prop.raw\n\n this.document.setProperty(this.nodes[index], name, serialized)\n }\n }\n }\n\n extractNode (node) {\n const name = node.childForFieldName('name').text\n const labels = getNodeLabels(node)\n const properties = parsePropertiesFromSchema(node, layerSchema)\n\n if (properties.bindings) {\n properties.bindings.parsed = (\n groupPhandleArrayBindings(properties.bindings.parsed)\n .map(parseKeyBinding)\n )\n }\n\n if (properties['sensor-bindings']) {\n properties['sensor-bindings'].parsed = (\n groupPhandleArrayBindings(properties['sensor-bindings'].parsed)\n .map(parseKeyBinding)\n )\n }\n\n return { name, labels, properties }\n }\n\n legacyParse (node) {\n const { name, labels, properties } = this.extractNode(node)\n const legacyNode = {\n name,\n labels,\n properties,\n identifier: name\n }\n\n if (properties.label) {\n legacyNode.label = properties.label.parsed\n }\n if (properties.bindings) {\n legacyNode.bindings = properties.bindings.parsed\n }\n if (properties['sensor-bindings']) {\n legacyNode.sensorBindings = properties['sensor-bindings'].parsed\n }\n\n return legacyNode\n }\n\n legacyParseNodes () {\n return this.nodes.map(node => this.legacyParse(node))\n }\n}\n\nmodule.exports = LayerCollection\n","const pick = require('lodash/pick')\n\nconst {\n findChildByIdentifier,\n findChildrenByIdentifier,\n findNodesWithCompatible\n} = require('devicetree/lib/helpers')\nconst { NodeCollection } = require('devicetree/lib/node-collection')\n\nconst BehaviorCollection = require('./behaviors')\nconst { groupMacroBindings, encodeKeyBinding } = require('../bindings')\n\nclass MacroCollection extends BehaviorCollection {\n managedProperties = [\n 'label',\n 'tap-ms',\n 'wait-ms'\n ]\n\n lookupContainerNode () {\n const rootNodes = findChildrenByIdentifier(this.document.tree.rootNode, '/')\n return findChildByIdentifier(rootNodes, 'macros')\n }\n\n injectContainerNode () {\n const keymap = findNodesWithCompatible(this.document.tree.rootNode, 'zmk,keymap').at(-1)\n this.document.insertTextBeforeNode(keymap, '\\nmacros {};\\n')\n }\n\n lookupNodes () {\n return findNodesWithCompatible(\n this.document.tree.rootNode,\n 'zmk,behavior-macro'\n )\n }\n\n injectNode (_, macro) {\n const name = macro.name.replace(/[^a-zA-Z0-9_]/g, '_')\n const last = this.nodes.at(-1)\n const nodeContent = (\n `${name}: ${name} {\n compatible = \"zmk,behavior-macro\";\n };`\n )\n\n if (last) {\n this.document.insertTextAfterNode(last, nodeContent)\n } else {\n this.document.addChildNode(this.container, nodeContent)\n }\n }\n\n updateNode (index, update) {\n const serialized = serializeMacroBindings(update.properties.bindings?.parsed || [])\n update.properties.bindings = {\n useRaw: true,\n raw: serialized\n }\n\n super.updateNode(index, update)\n }\n\n legacyParse (node) {\n return pick(this.extractNode(node), ['name', 'labels', 'properties'])\n }\n\n legacyParseNodes () {\n return this.nodes.map(node => this.legacyParse(node))\n }\n\n cleanupNodeProperties (index, update, existing) {\n const { cleanupNodeProperties } = NodeCollection.prototype\n return cleanupNodeProperties.call(this, index, update, existing)\n }\n}\n\nfunction serializeMacroBindings (bindings) {\n const serialized = groupMacroBindings(\n bindings.map(encodeKeyBinding)\n ).map(row => row.join(' '))\n\n return serialized.length === 1\n ? [`<${serialized[0]}>`]\n : serialized.map(row => `<${row}>`)\n}\n\nmodule.exports = MacroCollection\n","const filter = require('lodash/filter')\nconst last = require('lodash/last')\nconst reverse = require('lodash/reverse')\n\nconst { DevicetreeDocument } = require('devicetree')\nconst {\n nodesAreConsecutive,\n findChildByIdentifier,\n findChildrenByIdentifier,\n getLabeledItem\n} = require('devicetree/lib/helpers')\nconst { standardBehaviorIncludeFiles } = require('zmk-data/behaviors')\n\nconst MacroCollection = require('./collections/macros')\nconst ComboCollection = require('./collections/combos')\nconst LayerCollection = require('./collections/layers')\nconst BehaviorCollection = require('./collections/behaviors')\n\nclass KeymapDocument extends DevicetreeDocument {\n constructor (...args) {\n super(...args)\n this.macroCollection = new MacroCollection(this)\n this.comboCollection = new ComboCollection(this)\n this.layerCollection = new LayerCollection(this)\n this.behaviorCollection = new BehaviorCollection(this)\n }\n\n cleanup () {\n super.cleanup()\n delete this.layerCollection\n delete this.comboCollection\n delete this.macroCollection\n delete this.behaviorCollection\n }\n\n getChosenProperties () {\n const rootNodes = findChildrenByIdentifier(this.tree.rootNode, '/')\n const chosen = findChildByIdentifier(rootNodes, 'chosen')\n\n if (!chosen) {\n return {}\n }\n\n return chosen.namedChildren.reduce((acc, child) => {\n if (child.type === 'labeled_item') {\n child = getLabeledItem(child)\n }\n if (child.type === 'property') {\n const name = child.childForFieldName('name').text\n const value = child.childForFieldName('value').text\n acc[name] = value\n }\n\n return acc\n }, {})\n }\n\n mergeUpdated (updated, featureFlags = {}) {\n this.layerCollection.updateCollection(updated.layers)\n this.comboCollection.updateCollection(updated.combos)\n this.macroCollection.updateCollection(updated.macros)\n\n if (featureFlags.enableBehaviorEditing) {\n this.behaviorCollection.updateCollection(updated.behaviors)\n }\n }\n\n replaceBehaviourIncludes (updated) {\n const replacementText = updated.join('\\n') + '\\n'\n const behaviorIncludes = this.tree.rootNode.namedChildren.filter(node => (\n node.type === 'preproc_include' &&\n // TODO: update behavior overlays to just specify the include path and not\n // the include pre-processor statement. `startsWith` is necessary here\n // because preproc_include node parsing includes trailing newline(s).\n standardBehaviorIncludeFiles.some(line => node.text.startsWith(line))\n ))\n\n if (behaviorIncludes.length) {\n if (nodesAreConsecutive(behaviorIncludes)) {\n this.replaceRange(\n behaviorIncludes[0].startIndex,\n behaviorIncludes.at(-1).endIndex,\n ''\n )\n } else {\n for (const node of reverse(behaviorIncludes)) {\n this.removeNode(node)\n }\n }\n }\n\n const lastInclude = last(filter(\n this.tree.rootNode.children,\n { type: 'preproc_include' }\n ))\n const firstDefine = this.tree.rootNode.children.find(node => node.type === 'preproc_def')\n const firstDtNode = this.tree.rootNode.children.find(node => node.type === 'node')\n\n if (lastInclude) {\n this.insertTextAfterNode(lastInclude, replacementText)\n } else if (firstDefine || firstDtNode) {\n this.insertTextBeforeNode(\n firstDefine || firstDtNode,\n replacementText\n )\n }\n }\n}\n\nmodule.exports = KeymapDocument\n","const { getPropertyValues } = require('devicetree/lib/helpers/properties')\n\nconst MISSING_ROOT_NODE = 'MISSING_ROOT_NODE'\nconst USING_ZMK_NODEFREE_MACROS = 'USING_ZMK_NODEFREE_MACROS'\nconst USING_ZMK_MACRO_MACRO = 'USING_ZMK_MACRO_MACRO'\nconst USING_MULTIPLE_ROOT_NODES = 'USING_MULTIPLE_ROOT_NODES'\nconst USING_MIRYOKU_DTSI = 'USING_MIRYOKU_DTSI'\nconst USING_NON_ZMK_MACRO = 'USING_NON_ZMK_MACRO'\n\nfunction keymapUsesNodefreeConfigHelpers (document) {\n const macroNames = [\n 'ZMK_BEHAVIOR',\n 'ZMK_COMBO',\n 'ZMK_CONDITIONAL_LAYER',\n 'ZMK_LAYER',\n 'UC_MACRO'\n ]\n\n for (const node of document.tree.rootNode.namedChildren) {\n if (node.type === 'ERROR') {\n const { text } = node\n if (macroNames.some(name => text.startsWith(name))) {\n return USING_ZMK_NODEFREE_MACROS\n }\n }\n }\n}\n\nfunction keymapUsesMiryoku (document) {\n for (const node of document.tree.rootNode.namedChildren) {\n if (node.type === 'preproc_include') {\n if (node.childForFieldName('path').text.includes('miryoku.dtsi')) {\n return USING_MIRYOKU_DTSI\n }\n }\n }\n}\n\nfunction keymapBindingsUsePreprocessorMacros (document) {\n const zmkPreprocFunctions = [\n 'LA', 'LC', 'LG', 'LS',\n 'RA', 'RC', 'RG', 'RS',\n 'RGB_COLOR_HSB'\n ]\n\n for (const layerNode of document.layerCollection.nodes) {\n const [bindingsNode] = getPropertyValues(layerNode, 'bindings')\n const nonZmkPreprocFunction = bindingsNode.namedChildren.find(node => (\n node.type === 'call_expression' &&\n !zmkPreprocFunctions.includes(node.childForFieldName('function').text)\n ))\n\n if (nonZmkPreprocFunction) {\n return USING_NON_ZMK_MACRO\n }\n }\n}\n\nfunction keymapHasNoRootNodes (document) {\n for (let node of document.tree.rootNode.namedChildren) {\n if (node.type === 'labeled_item') {\n node = node.childForFieldName('item')\n }\n if (node.type === 'node' && node.childForFieldName('name').text === '/') {\n return\n }\n }\n\n return MISSING_ROOT_NODE\n}\n\n/**\n * Check if a devicetree document uses multiple root nodes.\n *\n * People sometimes organize different parts of a keymap (like behaviors and\n * combos) into separate instances of a root node. The devicetree compiler will\n * merge these root nodes into one, but preserving this for editing is annoying\n * and inefficient so I don't want to support it anymore.\n *\n * @param {DevicetreeDocument} document\n * @returns {String|undefined}\n */\nfunction keymapHasMultipleRootNodes (document) {\n let firstRootNode = null\n\n for (let node of document.tree.rootNode.namedChildren) {\n if (node.type === 'labeled_item') {\n node = node.childForFieldName('item')\n }\n if (node.type === 'node' && node.childForFieldName('name').text === '/') {\n if (firstRootNode !== null) {\n return USING_MULTIPLE_ROOT_NODES\n }\n\n firstRootNode = node\n }\n }\n}\n\n/**\n * This is just a last-ditch check to see if keymap parsing failed because of a\n * custom define that replaced the initial binding cell's behavior. This would\n * otherwise be caught by `keymapBindingsUsePreprocessorMacros` except that the\n * initial grouping fails.\n * @param {DevicetreeDocument} document\n */\nfunction keymapHasLayerBindingsWithNonBehaviorStarter (document) {\n return document.layerCollection.nodes.some(node => {\n const bindingCells = [].concat(...getPropertyValues(node, 'bindings'))\n .flatMap(integerCells => integerCells.namedChildren)\n const firstBindType = bindingCells[0]?.type\n\n return firstBindType && firstBindType !== 'reference'\n })\n}\n\nmodule.exports = {\n keymapHasNoRootNodes,\n keymapUsesNodefreeConfigHelpers,\n keymapUsesMiryoku,\n keymapBindingsUsePreprocessorMacros,\n keymapHasMultipleRootNodes,\n keymapHasLayerBindingsWithNonBehaviorStarter,\n warningFlags: {\n MISSING_ROOT_NODE,\n USING_ZMK_NODEFREE_MACROS,\n USING_ZMK_MACRO_MACRO,\n USING_MULTIPLE_ROOT_NODES,\n USING_MIRYOKU_DTSI,\n USING_NON_ZMK_MACRO\n }\n}\n","const compact = require('lodash/compact')\nconst { getParser } = require('devicetree')\nconst { resolveBehaviorParams } = require('zmk-data/parameters')\n\nconst KeymapDocument = require('./devicetree/keymap-document')\nconst {\n keymapUsesNodefreeConfigHelpers,\n keymapUsesMiryoku,\n keymapBindingsUsePreprocessorMacros,\n keymapHasNoRootNodes,\n keymapHasLayerBindingsWithNonBehaviorStarter,\n warningFlags: { USING_NON_ZMK_MACRO }\n} = require('./devicetree/sanity-checks')\nconst { parseStringLiteral } = require('devicetree/lib/helpers/values')\n\nasync function extractKeymapData (keymapText) {\n const parser = await getParser()\n const document = new KeymapDocument(parser, keymapText)\n\n try {\n // Behaviors need post-processing to determine types for their binding cells\n const behaviors = document.behaviorCollection.legacyParseNodes()\n resolveBehaviorParams(behaviors)\n\n return {\n warningFlags: extractWarnings(document),\n defines: extractDefines(document),\n headers: extractLocalHeaders(document),\n chosen: document.getChosenProperties(),\n behaviors,\n layers: document.layerCollection.legacyParseNodes(),\n combos: document.comboCollection.legacyParseNodes(),\n macros: document.macroCollection.legacyParseNodes()\n }\n } catch (err) {\n if (keymapHasLayerBindingsWithNonBehaviorStarter(document)) {\n return {\n warningFlags: [USING_NON_ZMK_MACRO],\n defines: {},\n headers: [],\n chosen: {},\n behaviors: [],\n layers: [],\n combos: [],\n macros: []\n }\n }\n console.error(err)\n return {\n warningFlags: ['KEYMAP_PARSING_FAILED'],\n defines: {},\n headers: [],\n chosen: {},\n behaviors: [],\n layers: [],\n combos: [],\n macros: []\n }\n } finally {\n document.cleanup()\n }\n}\n\nfunction extractWarnings (document) {\n return compact([\n keymapHasNoRootNodes(document),\n keymapUsesNodefreeConfigHelpers(document),\n keymapUsesMiryoku(document),\n keymapBindingsUsePreprocessorMacros(document)\n ])\n}\n\nfunction extractDefines (document) {\n return document.tree.rootNode.namedChildren.reduce((acc, node) => {\n if (node.type === 'preproc_def') {\n const name = node.childForFieldName('name').text\n const value = node.childForFieldName('value')?.text.trim()\n\n acc[name] = value\n }\n\n return acc\n }, {})\n}\n\nfunction extractLocalHeaders (document) {\n return document.tree.rootNode.namedChildren.reduce((acc, node) => {\n if (node.type === 'preproc_include') {\n const path = node.childForFieldName('path')\n if (path.type === 'string_literal') {\n acc.push(parseStringLiteral(path))\n }\n }\n\n return acc\n }, [])\n}\n\nmodule.exports = extractKeymapData\n","const omitBy = require('lodash/omitBy')\nconst renderLayout = require('keymap-layout-tools/lib/render')\n\nconst { encodeKeyBinding } = require('./devicetree/bindings')\n\nclass KeymapValidationError extends Error {\n constructor (errors) {\n super()\n this.name = 'KeymapValidationError'\n this.errors = errors\n }\n}\n\n// TODO: Rename this to something like \"hydrate\"?\nfunction encodeKeymap (layout, parsedKeymap) {\n /*\n This should basically become the standard format for a keymap when passed\n around the various layers of the backend.\n\n TODO: what do I want to do about keymap.json formatting? Should I call this a\n new version and update existing files on-the-fly?\n\n Also layer_names should be removed and the name (idenfitier?) + \"label\" should\n be given in the layer object.\n\n We can also analyze the unique set of behaviours used across all layers to\n determine ahead of time which headers to include.\n */\n return Object.assign({}, parsedKeymap, {\n layers: encodeLayers(parsedKeymap.layers, layout),\n combos: encodeCombos(parsedKeymap.combos)\n })\n}\n\nfunction encodeLayers (layers, layout) {\n return layers.map(layer => {\n // Newly created layers will specify name instead of identifier but still\n // use `layer.bindings` and `layer.label`\n if (layer.identifier || layer.bindings) {\n layer = {\n index: layer.index,\n name: layer.identifier || layer.name,\n labels: [],\n properties: {\n label: layer.label && { parsed: layer.label },\n bindings: layer.bindings && { parsed: layer.bindings },\n 'sensor-bindings': layer.sensorBindings && { parsed: layer.sensorBindings }\n }\n }\n }\n\n if (layer.properties.bindings?.parsed) {\n const { parsed } = layer.properties.bindings\n layer.properties.bindings = {\n parsed,\n useRaw: true,\n raw: `<\\n${renderLayout(layout, parsed.map(encodeKeyBinding))}\\n>`\n }\n }\n\n if (layer.properties.label && !layer.properties.label.parsed) {\n delete layer.properties.label\n }\n\n layer.properties = omitBy(layer.properties, value => !value)\n\n return layer\n })\n}\n\nfunction encodeCombos (combos) {\n return combos.map(combo => {\n if (combo.identifier) {\n combo = {\n index: combo.index,\n name: combo.identifier,\n labels: [],\n properties: {\n bindings: combo.bindings && { parsed: combo.bindings },\n 'key-positions': combo.keyPositions && { parsed: combo.keyPositions },\n 'timeout-ms': combo.timeoutMs && { parsed: combo.timeoutMs },\n 'slow-release': combo.slowRelease && { parsed: combo.slowRelease },\n layers: combo.layers?.length && { parsed: combo.layers }\n }\n }\n }\n\n combo.properties = omitBy(combo.properties, value => !value)\n\n if (!combo.properties.layers?.parsed?.length) {\n delete combo.properties.layers\n }\n\n return combo\n })\n}\n\nfunction parseKeymap (keymap) {\n // TODO: move all of this into extractKeymapData\n return Object.assign({}, keymap, {\n layers: keymap.layers.map((layer, i) => ({ ...layer, index: i })),\n combos: keymap.combos.map((combo, i) => ({ ...combo, index: i })),\n macros: keymap.macros.map((macro, i) => ({ ...macro, index: i })),\n behaviors: keymap.behaviors.map((behavior, i) => ({ ...behavior, index: i }))\n })\n}\n\nmodule.exports = {\n KeymapValidationError,\n encodeKeymap,\n encodeLayers,\n encodeCombos,\n parseKeymap\n}\n","const times = require('lodash/times')\n\nfunction renderLayout (layout, layer, opts = {}) {\n const { margin = 2 } = opts\n const table = layer.reduce((map, code, i) => {\n // TODO: this would be better as a loop over `layout`, checking for a\n // matching element in the `layer` array. Or, alternatively, an earlier\n // validation that asserts each layer is equal in length to the number of\n // keys in the layout.\n if (layout[i]) {\n const { row = 0, col } = layout[i]\n map[row] = map[row] || []\n map[row][col || map[row].length] = code\n }\n\n return map\n }, [])\n\n const rowIndices = Object.keys(table)\n const columns = Math.max(...rowIndices.map(i => table[i].length))\n const columnIndices = times(columns, n => n)\n const columnWidths = columnIndices.map(col => Math.max(\n ...rowIndices.map(row => table[row][col]?.length || 0)\n ))\n\n return table.map((row, i) => {\n return columnIndices.map(i => {\n const noMoreValues = row.slice(i).every(col => col === undefined)\n const padding = columnWidths[i] + (\n i === 0 ? '' : margin\n )\n\n if (noMoreValues) return ''\n if (!row[i]) return ' '.repeat(padding)\n return row[i].padStart(padding)\n }).join('').replace(/\\s+$/, '')\n }).join('\\n')\n}\n\nmodule.exports = renderLayout\n","/**\n * Remove common indentation from lines of a multiline string\n * @param {String} text a multiline string\n * @returns {String}\n */\nfunction dedent (text) {\n return _dedentedLines(text).join('\\n')\n}\n\nfunction _dedentedLines (text) {\n const lines = text.split('\\n')\n const minIndentation = lines.reduce((leastIndentation, line) => {\n const match = line.match(/^(\\s*)\\S/)\n\n if (!match) {\n return leastIndentation\n }\n\n return Math.min(leastIndentation, match[1].length)\n }, Infinity)\n\n return lines.map(line => (\n line.slice(0, minIndentation).match(/^\\s+$/)\n ? line.slice(minIndentation)\n : line\n ))\n}\n\n/**\n * Replace base indentation with a custom indentation string on all lines\n * @param {String} text\n * @param {String} indentation\n * @returns {String}\n */\nfunction reindent (text, indentation) {\n return _dedentedLines(text)\n .map(line => indentation + line)\n .join('\\n')\n}\n\nfunction getPosition (text, index) {\n let row, idx\n for (\n row = 0, idx = 0;\n idx !== -1;\n row++, idx = text.indexOf('\\n', idx + 1)\n );\n\n return { row, col: index - idx }\n}\n\nfunction removeStartingWhitespace (text) {\n return text.split('\\n')\n .reduce((lines, line) => {\n if (lines.length > 0 || line.match(/\\S/)) {\n lines.push(line)\n }\n return lines\n }, [])\n .join('\\n')\n}\n\nfunction removeTrailingWhitespace (text) {\n return text.split('\\n')\n .reverse()\n .reduce((lines, line) => {\n if (lines.length > 0 || line.match(/\\S/)) {\n lines.push(line)\n }\n return lines\n }, [])\n .reverse()\n .join('\\n')\n}\n\nmodule.exports = {\n dedent,\n reindent,\n getPosition,\n removeStartingWhitespace,\n removeTrailingWhitespace\n}\n","const merge = require('lodash/merge')\nconst isMatch = require('lodash/isMatch')\nconst uniq = require('lodash/uniq')\n\n/** @typedef {('string' | 'boolean' | 'int' | 'array' | 'phandle' | 'phandles' | 'phandle-array' | 'integer-union')} PropertyType */\n/** @typedef {{ type: PropertyType, required?: boolean, const?: any, default?: any, enum?: Array<any>, description?: string }} PropertyDefinition */\n/** @typedef {Object.<string, PropertyDefinition>} Properties */\n/** @typedef {{ description?: string, compatible: string, include: string, properties: Properties }} BehaviorSchema */\n/** @typedef {Object.<string, BehaviorSchema} BehaviorSchemas */\n/** @typedef {} BehaviorSchema */\n\n/** @type {BehaviorSchemas} */\nconst behaviorSchemas = require('./data/extracted-data/behavior-schemas.json')\n/** @type {BehaviorSchemas} */\nconst behaviorSchemaAdditions = require('./data/overlay-data/behavior-schemas-additions.json')\n\n/** @typedef {{ parsed: any, raw: string, useRaw?: boolean }} PropertyValue */\n/** @typedef {Object.<string, PropertyValue} ParsedProperties */\n/** @typedef {{ code: string, compatible: string, '#binding-cells': number, properties: ParsedProperties }} Behavior */\n\n/** @type {Array<Behavior>} */\nconst behaviorBindings = require('./data/extracted-data/behaviors.json')\n/** @type {Array<Behavior>} */\nconst behaviorAdditions = require('./data/overlay-data/behaviors-additions.json')\nconst behaviorSchemaOverlays = require('./data/overlay-data/behavior-schemas-overlay.json')\nconst behaviorOverlays = require('./data/overlay-data/behaviors-overlay.json')\n\nObject.assign(behaviorSchemas, behaviorSchemaAdditions)\nbehaviorBindings.push(...behaviorAdditions)\n\nfunction mergeBehaviorOverlays (base, overlays) {\n const baseValues = Array.isArray(base) ? base : Object.values(base)\n\n for (const value of baseValues) {\n for (const { match, ...overlay } of overlays) {\n if (isMatch(value, match)) {\n merge(value, overlay)\n }\n }\n }\n}\n\nmergeBehaviorOverlays(behaviorSchemas, behaviorSchemaOverlays)\nmergeBehaviorOverlays(behaviorBindings, behaviorOverlays)\n\nconst standardBehaviorIncludeFiles = uniq(\n behaviorOverlays.flatMap(overlay => overlay.includes || [])\n)\n\nfor (const behavior of behaviorBindings) {\n const schema = behaviorSchemas[behavior.compatible]\n merge(behavior, { schema })\n}\n\nmodule.exports = {\n behaviorSchemas,\n behaviorBindings,\n behaviorOverlays,\n behaviorSchemaOverlays,\n standardBehaviorIncludeFiles,\n mergeBehaviorOverlays\n}\n","const singleValue = value => ({ value: '&kp', params: [{ value, params: [] }] })\n\nconst patternMappings = [\n { pattern: /^[0-9]$/, convert: digit => singleValue(`N${digit}`) },\n { pattern: /^[a-z]$/, convert: char => singleValue(char.toUpperCase()) },\n {\n pattern: /^[A-Z]$/,\n convert: char => ({\n value: '&kp',\n params: [{\n value: 'LS',\n params: [{\n value: char.toUpperCase(),\n params: []\n }]\n }]\n })\n }\n]\n\nconst simpleMappings = {\n '!': singleValue('EXCL'),\n '@': singleValue('AT'),\n '#': singleValue('POUND'),\n '$': singleValue('DLLR'),\n '%': singleValue('PRCNT'),\n '^': singleValue('CARET'),\n '&': singleValue('AMPS'),\n '*': singleValue('STAR'),\n '(': singleValue('LPAR'),\n ')': singleValue('RPAR'),\n '\\n': singleValue('RET'),\n ' ': singleValue('SPACE'),\n '-': singleValue('MINUS'),\n '_': singleValue('UNDER'),\n '=': singleValue('EQUAL'),\n '+': singleValue('PLUS'),\n '[': singleValue('LBKT'),\n ']': singleValue('LBRC'),\n '{': singleValue('RBKT'),\n '}': singleValue('RBRC'),\n '\\\\': singleValue('BSLH'),\n '|': singleValue('PIPE'),\n '': singleValue('TILDE2'),\n ';': singleValue('SEMI'),\n ':': singleValue('COLON'),\n '\\'': singleValue('SQT'),\n '\"': singleValue('DQT'),\n '`': singleValue('GRAVE'),\n '~': singleValue('TILDE'),\n ',': singleValue('COMMA'),\n '<': singleValue('LT'),\n '.': singleValue('DOT'),\n '>': singleValue('GT'),\n '/': singleValue('FSLH'),\n '?': singleValue('QMARK')\n}\n\nfunction mapCharacter (char) {\n if (simpleMappings[char]) {\n return simpleMappings[char]\n }\n\n for (const { pattern, convert } of patternMappings) {\n if (char.match(pattern)) {\n return convert(char)\n }\n }\n}\n\nmodule.exports = {\n mapCharacter\n}\n","const keycodes = require('./data/extracted-data/keycodes.json')\nconst keycodeGlyphs = {\n basic: require('./data/overlay-data/keycode-glyphs.json'),\n unicode: require('./data/overlay-data/keycode-glyphs-unicode.json'),\n platforms: {\n mac: require('./data/overlay-data/keycode-glyphs-macos.json'),\n win: require('./data/overlay-data/keycode-glyphs-windows.json')\n }\n}\n\nmodule.exports = {\n keycodes,\n keycodeGlyphs\n}\n","const times = require('lodash/times')\nconst { behaviorSchemas, behaviorBindings } = require('./behaviors')\n\n/**\n * Parsing keymap gives us a number of custom behaviour definitions\n * Some custom behaviours may reference other behaviours\n * Some custom behaviours may reference other custom behaviours\n *\n * We need to add all new behaviour to a new map upon loading\n * After populating the map with all new behaviours we can resolve bind params\n *\n * Keep a list of \"visited\" behaviours\n * For each behaviour\n * For each behaviour referenced in bindings\n * Resolve behaviour reference to get params list\n * If behaviour reference already exists in list of visited behaviours, bail\n * If number of references to resolve exceeds X, bail\n */\n\nfunction BehaviorResolutionError (message) {\n this.message = message\n this.name = 'BehaviorResolutionError'\n}\n\n/** @typedef {string} Identifier */\n/** @typedef {string} Label */\n/** @typedef {{ parsed: any, raw: string, useRaw?: boolean }} PropertyValue */\n/** @typedef {Object.<string, PropertyValue>} Properties */\n/** @typedef {{ name: string, labels: Array<string>, properties: Properties }} ParsedBehavior */\n\nfunction parseNumBindingCells (behavior, prop = '#binding-cells') {\n const parsed = behavior.properties?.[prop]?.parsed\n\n if (typeof parsed === 'number') {\n return parsed\n }\n\n // For unrecognized behaviors we don't have the schema to parse the\n // \"#binding-cells\" property like we'd expect, so let's assume its a single\n // integer literal and parse the raw value\n const raw = behavior.properties?.[prop]?.raw || '<>'\n const match = raw.match(/<(\\d+)>/)\n\n if (match) {\n return Number(match[1])\n }\n}\n\nfunction behaviorMap (map, behavior) {\n for (const label of behavior.labels) {\n map[`&${label}`] = behavior\n }\n return map\n}\n\n/**\n * Attempt to provide parameter types for behaviours with binding-cells.\n * @param {Array<ParsedBehavior>} behaviors - custom behavior definitions\n */\nfunction resolveBehaviorParams (behaviors) {\n const standardBindingsMap = behaviorBindings.reduce(behaviorMap, {})\n // Here we attempt to resolve the binding to a \"known\" behaviour for which\n // I have already manually described the parameters. Failing that, this\n // would fall back to a single \"code\" parameter for each. This assumes\n // that a custom hold-tap wouldn't want something like \"hold for layer\"\n // and \"tap to connect to BT profile 1\".\n const newBindingsMap = behaviors.reduce(behaviorMap, {})\n\n /**\n * @param {ParsedBehavior} behavior\n * @param {Array<string>} [queue=[]]\n * @returns {void}\n */\n function resolve (behavior, queue = []) {\n if ('params' in behavior) {\n return behavior.params\n }\n\n const compatible = behavior.properties?.compatible?.parsed\n const schema = behaviorSchemas[compatible]\n\n const bindingsType = schema?.properties?.bindings?.type\n const bindingCells = parseNumBindingCells(behavior) ?? parseNumBindingCells(behavior, '#sensor-binding-cells')\n const bindings = (behavior.properties?.bindings?.parsed || [])\n\n // console.log('resolving for', {\n // compatible,\n // schema,\n // bindingsType,\n // bindingCells,\n // bindings\n // })\n\n if (!bindingCells) {\n return []\n }\n\n // A `bindings` prop of type `phandle-array` means the bindings are already\n // given along with binding cell values and don't need further params.\n if (bindingsType === 'phandle-array') {\n return []\n }\n\n if (!bindings.length) {\n return times(bindingCells, () => ({ type: 'string', raw: true }))\n }\n\n // This implementation relies on the existing pattern for behaviors which\n // reference other behaviors without parameters (hold-tap and sticky-key)\n // will only provide a single parameter to each referenced behavior without\n // concerning itself with the referenced behavior's binding cell count.\n // A possible future exception to this is parameterized macros:\n // https://github.com/zmkfirmware/zmk/pull/1232#issuecomment-1478977559\n // This will require re-visiting this solution.\n return bindings.reduce((params, binding) => {\n // This implies the bindings property we're inspecting is actually a\n // phandles-array type (behavior with params) and not phandle/phandles.\n // This shouldn't happen and stricter checking earlier on would be wise.\n if (!binding.startsWith('&')) {\n return params\n }\n\n if (queue.includes(binding)) {\n throw new BehaviorResolutionError(`Circular reference in bindings: \"&${behavior.labels[0]}\" -> \"${binding}\".`)\n } else if (queue.length > 3) {\n throw new BehaviorResolutionError('Reference depth limit exceeded.')\n }\n\n const nextBehavior = newBindingsMap[binding] || standardBindingsMap[binding]\n\n // Not sure if I'm ok with this. Previously the idea was that a behavior\n // referencing an unrecognized behavior cannot resolve parameters at all,\n // whereas now it just treats that as having a single raw parameter and\n // includes an error message property that nothing else uses.\n if (!nextBehavior) {\n behavior.error = `Unrecognized behavior binding \"${binding}\".`\n return [...params, { raw: true }]\n }\n\n try {\n nextBehavior.params = resolve(nextBehavior, [...queue, binding])\n params.push(nextBehavior.params[0] || { type: 'placeholder' })\n } catch (error) {\n if (error instanceof BehaviorResolutionError) {\n nextBehavior.error = error.message\n nextBehavior.params = []\n }\n throw error\n }\n\n return params\n }, [])\n }\n\n for (const behavior of behaviors) {\n // if (!behavior.properties.bindings) {\n // continue\n // }\n\n try {\n behavior.params = resolve(behavior)\n } catch (error) {\n if (!(error instanceof BehaviorResolutionError)) {\n throw error\n }\n\n console.error('Failed to resolve behavior parameters', error)\n behavior.error = error.message\n behavior.params = times(parseNumBindingCells(behavior) || 0, () => ({ raw: true }))\n }\n }\n}\n\nmodule.exports = {\n resolveBehaviorParams\n}\n"],"names":["module","exports","removeStartingWhitespace","removeTrailingWhitespace","reindent","dedent","require","getLabeledItem","getNodeLabels","DEFAULT_INDENT","DEFAULT_MULTILINE_INTEGER_CELLS_INDENT","isMultilineNode","node","text","indexOf","isInlineComment","type","previousSibling","endPosition","row","startPosition","getNodeIndentation","tab","repeat","getNodeDepth","n","depth","stop","tree","rootNode","parent","id","shouldIncludeBlank","nodeA","nodeB","sameType","namedChildren","length","slice","some","hasAddress","childForFieldName","getAddress","formatLabels","labels","map","join","formatNode","options","indent","identifier","children","indentation","formatChildren","reduce","lines","childNode","i","arr","push","multilineIntegerCellsIndent","noValue","simpleValue","singleIntegerCell","bindingsLines","split","concat","line","formatPropertyNode","trimEnd","getModelineConfiguration","config","contents","startsWith","trim","match","key","jsonValue","value","JSON","parse","Object","assign","assert","reverse","getNodeLabelNodes","getNodeChildrenByFieldName","fieldName","cursor","walk","gotoFirstChild","isNamed","currentNode","isField","currentFieldName","gotoNextSibling","delete","findChildrenByIdentifier","nameOrMatch","filter","find","sub","nodesAreConsecutive","nodes","every","nextSibling","label","labeledItemNode","findChildByIdentifier","listNodes","opts","stripNewlines","limit","replace","console","log","parseStringLiteral","parseIntegerCells","parseIntegerArray","parsePhandles","parsePhandle","parsePhandleArray","parseIntegerUnion","serializeIntValue","serializeArrayValue","findNodeProperty","propertyName","getPropertyNode","child","getPropertyValues","property","propertyNode","parsePropertyFromSchema","schema","values","getProperty","syntaxNode","name","getPropertyValue","parsePropertiesFromSchema","keys","properties","prop","propSchema","undefined","parsed","serializePropertyFromSchema","phandle","bindings","group","v","toString","BreadthFirstIterator","maxDepth","queue","current","shift","DepthFirstIterator","stack","unshift","searchTree","predicate","single","depthFirst","iter","matches","createPredicateForCompatible","compatible","RegExp","test","TypeError","findLabeledItem","findNodeByIdentifier","findNodeWithCompatible","findNodesWithCompatible","isNegativeInteger","isNumberishType","includes","isBindingType","isBindingRef","extractInteger","Number","flatMap","cells","serializeIntegerCell","sanitizeIdentifier","ReferenceError","difference","isEqual","partition","NodeCollection","managedProperties","_cached_container_node","_cached_container_tree_version","_cached_collection_nodes","_cached_collection_tree_version","constructor","document","this","lookupContainerNode","bind","injectContainerNode","lookupNodes","injectNode","container","_parse_version","updateCollection","collection","flushChanges","originalIndices","reusedIndices","index","removedIndices","updates","additions","updateNode","removeNode","update","existing","extractNode","updateNodeName","updateNodeLabels","updateNodeProperties","cleanupNodeProperties","replaceNode","replaceNodeLabels","setProperty","deleteProperty","acc","raw","extractCollection","sortBy","TreeSitter","getPosition","_parser","getParser","async","init","language","Language","load","global","window","__dirname","setLanguage","DevicetreeDocument","parser","_enableChangeBuffering","_bufferedChanges","cleanup","inputEdit","replacementText","startIndex","newEndIndex","_reparse","chunks","nextUpdate","prevEnd","oldEndIndex","preChunk","chunk","newContent","documentText","precedingNewline","lastIndexOf","start","replacement","endIndex","oldEndPosition","newEndPosition","replaceRange","skipToIndex","source","labeledNode","newLabels","labelNodes","sorted","serializedLabels","insertTextBeforeNode","insertTextAfterNode","addChildNode","parentNode","closingBrace","newText","flatten","get","keyBy","uniq","behaviorBindings","KeymapDocument","encodeKeymap","behavioursByBind","layout","keymap","original","featureFlags","encoded","behaviourHeaders","keybinds","layers","layer","comboBinds","combos","macroBinds","macros","getBehavioursUsed","devicetreeKeymap","mergeUpdated","replaceBehaviourIncludes","err","error","groupPhandleArrayBindings","bindingCells","binding","MACRO_CONTROL_BEHAVIOURS","encodeBindValue","params","paramString","parseBindings","parseKeyBinding","paramsPattern","code","s","defines","groupMacroBindings","rows","behaviourBind","at","encodeKeyBinding","behaviorSchemas","rootNodes","_","behavior","last","nodeContent","extracted","super","extractedProp","bindStrings","aliases","bindingsValue","bindCode","legacyParseNodes","serialized","useRaw","bindString","comboSchema","combo","legacyParse","legacyNode","legacyMapping","layerSchema","updateLayerPositions","positionMap","nextIndex","j","targetIndexOrder","sensorBindings","pick","BehaviorCollection","macro","serializeMacroBindings","prototype","call","standardBehaviorIncludeFiles","MacroCollection","ComboCollection","LayerCollection","args","macroCollection","comboCollection","layerCollection","behaviorCollection","getChosenProperties","chosen","updated","enableBehaviorEditing","behaviors","behaviorIncludes","lastInclude","firstDefine","firstDtNode","MISSING_ROOT_NODE","USING_ZMK_NODEFREE_MACROS","USING_MULTIPLE_ROOT_NODES","USING_MIRYOKU_DTSI","USING_NON_ZMK_MACRO","keymapHasNoRootNodes","keymapUsesNodefreeConfigHelpers","macroNames","keymapUsesMiryoku","keymapBindingsUsePreprocessorMacros","zmkPreprocFunctions","layerNode","bindingsNode","keymapHasMultipleRootNodes","firstRootNode","keymapHasLayerBindingsWithNonBehaviorStarter","firstBindType","integerCells","warningFlags","USING_ZMK_MACRO_MACRO","compact","resolveBehaviorParams","extractWarnings","extractDefines","extractLocalHeaders","path","keymapText","headers","omitBy","renderLayout","KeymapValidationError","Error","errors","encodeLayers","encodeCombos","keyPositions","timeoutMs","slowRelease","parsedKeymap","parseKeymap","times","margin","table","col","rowIndices","columns","Math","max","columnIndices","columnWidths","noMoreValues","padding","padStart","_dedentedLines","minIndentation","leastIndentation","min","Infinity","idx","merge","isMatch","behaviorSchemaAdditions","behaviorAdditions","behaviorSchemaOverlays","behaviorOverlays","mergeBehaviorOverlays","base","overlays","baseValues","Array","isArray","overlay","singleValue","patternMappings","pattern","convert","digit","char","toUpperCase","simpleMappings","mapCharacter","keycodes","keycodeGlyphs","basic","unicode","platforms","mac","win","BehaviorResolutionError","message","parseNumBindingCells","behaviorMap","standardBindingsMap","newBindingsMap","resolve","bindingsType","nextBehavior"],"sourceRoot":""}
\ No newline at end of file |