Source: Filter.js

  1. const turf = require('./turf')
  2. const strsearch2regexp = require('strsearch2regexp')
  3. const filterJoin = require('./filterJoin')
  4. const OverpassFrontend = require('./defines')
  5. const qlFunctions = require('./qlFunctions/__index__')
  6. const parseString = require('./parseString')
  7. const parseParentheses = require('./parseParentheses')
  8. const qlFunction = require('./qlFunctions/qlFunction')
  10. function qlesc (str) {
  11.   return '"' + str.replace(/"/g, '\\"') + '"'
  12. }
  14. function compile (part, options = {}) {
  15.   if (Array.isArray(part)) {
  16.     return part.map(compile).join('')
  17.   }
  19.   if (part.or) {
  20.     return { or: part.or.map(compile) }
  21.   }
  23.   const keyRegexp = (part.keyRegexp ? '~' : '')
  25.   if (part instanceof qlFunction) {
  26.     return part.toString(options)
  27.   }
  29.   if (part.type) {
  30.     return part.type
  31.   }
  33.   switch (part.op) {
  34.     case 'has_key':
  35.       if (part.keyRegexp === 'i') {
  36.         return '[~' + qlesc(part.key) + '~".",i]'
  37.       } else if (keyRegexp) {
  38.         return '[~' + qlesc(part.key) + '~"."]'
  39.       } else {
  40.         return '[' + keyRegexp + qlesc(part.key) + ']'
  41.       }
  42.     case 'not_exists':
  43.       return '[!' + qlesc(part.key) + ']'
  44.     case '=':
  45.     case '!=':
  46.     case '~':
  47.     case '!~':
  48.       return '[' + keyRegexp + qlesc(part.key) + part.op + qlesc(part.value) + ']'
  49.     case '~i':
  50.     case '!~i':
  51.       return '[' + keyRegexp + qlesc(part.key) + part.op.substr(0, part.op.length - 1) + qlesc(part.value) + ',i]'
  52.     case 'has':
  53.       return '[' + keyRegexp + qlesc(part.key) + '~' + qlesc('^(.*;|)' + part.value + '(|;.*)$') + ']'
  54.     case 'strsearch':
  55.       return '[' + keyRegexp + qlesc(part.key) + '~' + qlesc(strsearch2regexp(part.value)) + ',i]'
  56.     default:
  57.       throw new Error('unknown operator' + JSON.stringify(part))
  58.   }
  59. }
  61. function test (ob, part) {
  62.   if (Array.isArray(part)) {
  63.     return part.every(part => test(ob, part))
  64.   }
  66.   if (part.type) {
  67.     return ob.type === part.type
  68.   }
  70.   if (part.or) {
  71.     return part.or.some(part => test(ob, part))
  72.   }
  74.   if (part.and) {
  75.     return part.and.every(part => test(ob, part))
  76.   }
  78.   if (part.keyRegexp) {
  79.     let regex
  80.     if (part.value) {
  81.       regex = new RegExp(part.value, part.op.match(/i$/) ? 'i' : '')
  82.     }
  84.     const keyRegex = new RegExp(part.key, part.keyRegexp === 'i' ? 'i' : '')
  86.     for (const k in ob.tags) {
  87.       if (k.match(keyRegex)) {
  88.         if (regex) {
  89.           if (ob.tags[k].match(regex)) {
  90.             return true
  91.           }
  92.         } else {
  93.           return true
  94.         }
  95.       }
  96.     }
  97.     return false
  98.   }
  100.   if (part instanceof qlFunction) {
  101.     return part.test(ob)
  102.   }
  104.   switch (part.op) {
  105.     case 'has_key':
  106.       return ob.tags && (part.key in ob.tags)
  107.     case 'not_exists':
  108.       return ob.tags && (!(part.key in ob.tags))
  109.     case '=':
  110.       return ob.tags && (part.key in ob.tags) && (ob.tags[part.key] === part.value)
  111.     case '!=':
  112.       return ob.tags && (!(part.key in ob.tags) || (ob.tags[part.key] !== part.value))
  113.     case '~':
  114.       return ob.tags && (part.key in ob.tags) && (ob.tags[part.key].match(part.value))
  115.     case '!~':
  116.       return ob.tags && (!(part.key in ob.tags) || (!ob.tags[part.key].match(part.value)))
  117.     case '~i':
  118.       return ob.tags && (part.key in ob.tags) && (ob.tags[part.key].match(new RegExp(part.value, 'i')))
  119.     case '!~i':
  120.       return ob.tags && (!(part.key in ob.tags) || !ob.tags[part.key].match(new RegExp(part.value, 'i')))
  121.     case 'has':
  122.       return ob.tags && (part.key in ob.tags) && (ob.tags[part.key].split(/;/).indexOf(part.value) !== -1)
  123.     case 'strsearch':
  124.       return ob.tags && (part.key in ob.tags) && (ob.tags[part.key].match(new RegExp(strsearch2regexp(part.value), 'i')))
  125.     default:
  126.       console.log('match: unknown operator in filter', part)
  127.       return false
  128.   }
  129. }
  131. function parse (def, rek = 0) {
  132.   const script = []
  133.   let current = []
  135.   let mode = 0
  136.   let key
  137.   let value
  138.   let op
  139.   let m
  140.   let keyRegexp = false
  141.   let notExists = null
  142.   while (true) {
  143.     // console.log('rek' + rek, 'mode' + mode + '|', def.substr(0, 20), '->', script, 'next:', current)
  144.     if (mode === 0) {
  145.       if (def.match(/^\s*$/)) {
  146.         return [rek === 0 && script.length === 1 ? script[0] : script, def]
  147.       }
  149.       keyRegexp = false
  150.       m = def.match(/^\s*(node|way|relation|rel|nwr|\()/)
  151.       if (m && m[1] === '(') {
  152.         def = def.slice(m[0].length)
  154.         let parts
  155.         [parts, def] = parse(def, rek + 1)
  156.         mode = 1
  158.         script.push({ or: parts })
  159.         current = []
  160.       } else if (m) {
  161.         if (m[1] === 'rel') {
  162.           current.push({ type: 'relation' })
  163.         } else if (m[1] === 'nwr') {
  164.           // nothing
  165.         } else {
  166.           current.push({ type: m[1] })
  167.         }
  168.         mode = 10
  169.         def = def.slice(m[0].length)
  170.       } else {
  171.         throw new Error("Can't parse query, expected type of object (e.g. 'node'): " + def)
  172.       }
  173.     } else if (mode === 1) {
  174.       m = def.match(/^\s*\)\s*;?\s*/)
  175.       if (m) {
  176.         if (rek === 0) {
  177.           return [script.length === 1 ? script[0] : script, def]
  178.         } else {
  179.           def = def.slice(m[0].length)
  180.           return [script, def]
  181.         }
  182.       } else {
  183.         mode = 0
  184.       }
  185.     } else if (mode === 10) {
  186.       const m = def.match(/^\s*(\[|\(|;)/)
  187.       if (m && m[1] === '[') {
  188.         def = def.slice(m[0].length)
  189.         mode = 11
  190.       } else if (m && m[1] === '(') {
  191.         def = def.slice(m[0].length - 1)
  192.         mode = 20
  193.       } else if (m && m[1] === ';') {
  194.         def = def.slice(m[0].length)
  195.         script.push(current)
  196.         current = []
  197.         notExists = null
  198.         mode = 1
  199.       } else if (!m && def.match(/^\s*$/)) {
  200.         if (current.length) {
  201.           script.push(current)
  202.         }
  203.         return [rek === 0 && script.length === 1 ? script[0] : script, '']
  204.       } else {
  205.         throw new Error("Can't parse query, expected '[' or ';': " + def)
  206.       }
  207.     } else if (mode === 11) {
  208.       m = def.match(/^(\s*)(([~!])\s*)?([a-zA-Z0-9_]+|"|')/)
  209.       if (m && m[2]) {
  210.         if (m[3] === '~') {
  211.           keyRegexp = true
  212.         } else if (m[3] === '!') {
  213.           notExists = true
  214.         }
  215.       }
  216.       if (m && (m[4] === '"' || m[4] === "'")) {
  217.         def = def.slice(m[1].length + (m[2] || '').length)
  218.         const x = parseString(def)
  219.         key = x[0]
  220.         def = x[1]
  221.         mode = 12
  222.       } else if (m) {
  223.         key = m[4]
  224.         def = def.slice(m[0].length)
  225.         mode = 12
  226.       } else {
  227.         throw new Error("Can't parse query, expected key: " + def)
  228.       }
  229.     } else if (mode === 12) {
  230.       m = def.match(/^\s*(=|!=|~|!~|\^|]|%)/)
  231.       if (m && m[1] === ']') {
  232.         const entry = { key, op: 'has_key' }
  233.         if (keyRegexp) {
  234.           entry.keyRegexp = true
  235.         }
  236.         if (notExists) {
  237.           entry.op = 'not_exists'
  238.         }
  239.         current.push(entry)
  240.         def = def.slice(m[0].length)
  241.         notExists = null
  242.         mode = 10
  243.       } else if (m) {
  244.         if (notExists) {
  245.           throw new Error("Can't parse query, expected ']': " + def)
  246.         }
  248.         op = m[1] === '^' ? 'has' : m[1] === '%' ? 'strsearch' : m[1]
  249.         mode = 13
  250.         def = def.slice(m[0].length)
  251.       } else {
  252.         throw new Error("Can't parse query, expected operator or ']': " + def)
  253.       }
  254.     } else if (mode === 13) {
  255.       m = def.match(/^(\s*)([a-zA-Z0-9_]+|"|')/)
  256.       if (m && (m[2] === '"' || m[2] === "'")) {
  257.         def = def.slice(m[1].length)
  258.         const x = parseString(def)
  259.         value = x[0]
  260.         def = x[1]
  261.         mode = 14
  262.       } else if (m) {
  263.         value = m[2]
  264.         def = def.slice(m[0].length)
  265.         mode = 14
  266.       } else {
  267.         throw new Error("Can't parse query, expected value: " + def)
  268.       }
  269.     } else if (mode === 14) {
  270.       m = def.match(/^\s*(,i)?\]/)
  271.       if (m) {
  272.         if (m[1] === ',i') {
  273.           if (op === '~' || op === '!~') {
  274.             op += 'i'
  275.           } else {
  276.             throw new Error("Can't parse query, expected ']': " + def)
  277.           }
  278.         }
  280.         const entry = { key, op }
  281.         if (value === '.') {
  282.           entry.op = 'has_key'
  283.         } else {
  284.           entry.value = value
  285.         }
  287.         if (keyRegexp) {
  288.           entry.keyRegexp = op.match(/^!?~i$/) ? 'i' : true
  289.         }
  290.         current.push(entry)
  291.         mode = 10
  292.         def = def.slice(m[0].length)
  293.       } else {
  294.         throw new Error("Can't parse query, expected ']': " + def)
  295.       }
  296.     } else if (mode === 20) {
  297.       const r = parseParentheses(def)
  298.       def = r[1]
  299.       const mId = r[0].match(/^\s*(\d+)\s*$/)
  300.       const mBbox = r[0].match(/^((\s*-?\d+(.\d+)?\s*,){3}\s*-?\d+(.\d+)?\s*)$/)
  301.       const m = r[0].match(/^\s*(\w+)\s*:\s*(.*)\s*$/)
  302.       /* eslint-disable new-cap */
  303.       if (mId) {
  304.         current.push(new qlFunctions.id(mId[1]))
  305.         mode = 10
  306.       } else if (mBbox) {
  307.         current.push(new qlFunctions.bbox(mBbox[1]))
  308.         mode = 10
  309.       } else if (m) {
  310.         const fun = m[1]
  311.         if (!qlFunctions[fun]) {
  312.           throw new Error('Unsupported filter function: ' + fun)
  313.         }
  314.         current.push(new qlFunctions[fun](m[2]))
  315.         mode = 10
  316.       } else {
  317.         throw new Error("Can't parse query, expected id, bbox or function: " + def)
  318.       }
  319.       /* eslint-enable new-cap */
  320.     }
  321.   }
  322. }
  324. function check (def) {
  325.   if (typeof def === 'string') {
  326.     const result = parse(def)
  327.     if (result[1].trim()) {
  328.       throw new Error("Can't parse query, trailing characters: " + result[1])
  329.     }
  330.     return result[0]
  331.   } else if (def === null) {
  332.     return
  333.   } else if (typeof def === 'object' && def instanceof Filter) {
  334.     def = def.def
  335.   } else if (Array.isArray(def)) {
  336.     def = def.map(d => check(d))
  337.   }
  338.   if (def.and) {
  339.     def.and = def.and.map(p => check(p))
  340.   }
  341.   if (def.or) {
  342.     def.or = def.or.map(p => check(p))
  343.   } else if (def.fun && !(def instanceof qlFunction)) {
  344.     def = new qlFunctions[def.fun](def.value)
  345.   }
  347.   return def
  348. }
  350. /**
  351.  * A Filter into OSM data. A simplified version of <a href='https://wiki.openstreetmap.org/wiki/Overpass_API/Overpass_QL'>Overpass QL</a>.
  352.  *
  353.  * <p>Either a single query (e.g. <tt>node[amenity=restaurant];</tt>) or a combined query (e.g. <tt>(node[amenity=restaurant];way[amenity=restaurant];);</tt>).<br>
  354.  * A single query statement consists of a type (e.g. 'node', 'way', 'relation', 'nwr' (node, way or relation)) and optional filters:<ul>
  355.  * <li>(Not) Equals (=, !=): <tt>[amenity=restaurant]</tt> or <tt>["amenity"="restaurant"]</tt> resp. <tt>["amenity"!="restaurant"]</tt>.
  356.  * <li>Regular Expression: <tt>[amenity~"^(restaurant|cafe)$"]</tt> resp. negated: <tt>[amenity!~"^(restaurant|cafe)$"]</tt>
  357.  * <li>Key regular expression: <tt>[~"cycleway"~"left"]</tt> (key has to match cycleway and its value match left)
  358.  * <li>Key (not) exists: <tt>[amenity]</tt> or <tt>["amenity"]</tt> resp. <tt>[!amenity]</tt>
  359.  * <li>Array search: <tt>[cuisine^kebap]</tt>: search for cuisine tags which exactly include 'kebap' (semicolon-separated values, e.g. <tt>cuisine=kebap;pizza</tt>).
  360.  * <li>String search: <tt>[name%cafe]</tt>: search for name tags which are similar to cafe, e.g. "café". (see https://github.com/plepe/strsearch2regexp for details).
  361.  * </ul>
  362.  * More advanced queries are not supported.</p>
  363.  *
  364.  * @param {string|object} query
  365.  */
  366. class Filter {
  367.   uniqId () {
  368.     this._uniqId = (this._uniqId || 0) + 1
  369.     return this._uniqId
  370.   }
  372.   constructor (def) {
  373.     if (!def) {
  374.       this.def = []
  375.       return
  376.     }
  378.     this.def = check(def)
  379.   }
  381.   /**
  382.    * Check if an object matches this filter
  383.    * @param {OverpassNode|OverpassWay|OverpassRelation} ob an object from Overpass API
  384.    * @return {boolean}
  385.    */
  386.   match (ob, def) {
  387.     if (!def) {
  388.       def = this.def
  389.     }
  391.     if (Array.isArray(def) && Array.isArray(def[0])) {
  392.       // script with several statements detected. only use the last one, as previous statements
  393.       // can't have an effect on the last statement yet.
  394.       def = def[def.length - 1]
  395.     }
  397.     if (def.or) {
  398.       return def.or.some(part => this.match(ob, part))
  399.     }
  401.     if (def.and) {
  402.       return def.and.every(test.bind(this, ob))
  403.     }
  405.     return def.filter(test.bind(this, ob)).length === def.length
  406.   }
  408.   /**
  409.    * Convert query to a string representation
  410.    * @return {string}
  411.    */
  412.   toString (def) {
  413.     return this.toQl({ toString: true }, def)
  414.   }
  416.   /**
  417.    * Convert query to Overpass QL
  418.    * @param {object} [options] Additional options
  419.    * @param {string} [options.inputSet=''] Specify input set (e.g.'.foo').
  420.    * @param {string} [options.outputSet=''] Specify output set (e.g.'.foo').
  421.    * @return {string}
  422.    */
  423.   toQl (options = {}, def) {
  424.     if (!def) {
  425.       def = this.def
  426.     }
  428.     if (Array.isArray(def) && Array.isArray(def[0])) {
  429.       return def.map(d => this.toQl(options, d)).join('')
  430.     }
  432.     if (def.or) {
  433.       return '(' + def.or.map(part => {
  434.         const subOptions = JSON.parse(JSON.stringify(options))
  435.         subOptions.inputSet = options.inputSet
  436.         subOptions.outputSet = ''
  437.         return this.toQl(subOptions, part)
  438.       }).join('') + ')' + (options.outputSet ? '->' + options.outputSet : '') + ';'
  439.     }
  441.     if (def.and) {
  442.       const first = def.and[0]
  443.       const last = def.and[def.and.length - 1]
  444.       const others = def.and.concat().slice(1, def.and.length - 1)
  445.       const set = '.x' + this.uniqId()
  446.       const subOptions1 = JSON.parse(JSON.stringify(options))
  447.       const subOptions2 = JSON.parse(JSON.stringify(options))
  448.       const subOptions3 = JSON.parse(JSON.stringify(options))
  449.       subOptions1.outputSet = set
  450.       subOptions2.inputSet = set
  451.       subOptions2.outputSet = set
  452.       subOptions3.inputSet = set
  454.       return this.toQl(subOptions1, first) +
  455.         others.map(part => this.toQl(subOptions2, part)).join('') +
  456.         this.toQl(subOptions3, last)
  457.     }
  459.     if (!options.inputSet) {
  460.       options.inputSet = ''
  461.     }
  463.     if (!options.outputSet) {
  464.       options.outputSet = ''
  465.     }
  467.     const parts = def.filter(part => part.type)
  468.     let types
  470.     switch (parts.length) {
  471.       case 0:
  472.         types = ['nwr']
  473.         break
  474.       case 1:
  475.         types = [parts[0].type]
  476.         break
  477.       default:
  478.         throw new Error('Filter: only one type query allowed!')
  479.     }
  481.     const queries = filterJoin(def
  482.       .filter(part => !part.type)
  483.       .map(part => compile(part, options)))
  485.     let result
  486.     if (queries.length > 1) {
  487.       result = '(' + queries.map(q => types.map(type => type + options.inputSet + q).join(';')).join(';') + ';)'
  488.     } else if (types.length === 1) {
  489.       result = types[0] + options.inputSet + queries[0]
  490.     } else {
  491.       result = '(' + types.map(type => type + options.inputSet + queries[0]).join(';') + ';)'
  492.     }
  494.     return result + (options.outputSet ? '->' + options.outputSet : '') + ';'
  495.   }
  497.   /**
  498.    * Convert query to LokiJS query for local database. If the property 'needMatch' is set on the returned object, an additional match() should be executed for each returned object, as the query can't be fully compiled (and the 'needMatch' property removed).
  499.    * @param {object} [options] Additional options
  500.    * @return {object}
  501.    */
  502.   toLokijs (options = {}, def) {
  503.     if (!def) {
  504.       def = this.def
  505.     }
  507.     if (Array.isArray(def) && Array.isArray(def[0])) {
  508.       // script with several statements detected. only compile the last one, as previous statements
  509.       // can't have an effect on the last statement yet.
  510.       def = def[def.length - 1]
  511.     }
  513.     if (def.or) {
  514.       let needMatch = false
  516.       const r = {
  517.         $or:
  518.         def.or.map(part => {
  519.           const r = this.toLokijs(options, part)
  520.           if (r.needMatch) {
  521.             needMatch = true
  522.           }
  523.           delete r.needMatch
  524.           return r
  525.         })
  526.       }
  528.       // if the $or has elements that are always true, remove whole $or
  529.       if (r.$or.filter(p => Object.keys(p).length === 0).length > 0) {
  530.         delete r.$or
  531.       }
  533.       if (needMatch) {
  534.         r.needMatch = true
  535.       }
  537.       return r
  538.     }
  540.     if (def.and) {
  541.       let needMatch = false
  543.       const r = {
  544.         $and:
  545.         def.and
  546.           .map(part => {
  547.             const r = this.toLokijs(options, part)
  548.             if (r.needMatch) {
  549.               needMatch = true
  550.             }
  551.             delete r.needMatch
  552.             return r
  553.           })
  554.           .filter(part => Object.keys(part).length)
  555.       }
  557.       if (needMatch) {
  558.         r.needMatch = true
  559.       }
  561.       return r
  562.     }
  564.     const query = {}
  565.     let orQueries = []
  567.     if (!Array.isArray(def)) {
  568.       def = [def]
  569.     }
  571.     def.forEach(filter => {
  572.       let k, v
  573.       if (filter.keyRegexp) {
  574.         k = 'needMatch'
  575.         v = true
  576.         // can't query for key regexp, skip
  577.       } else if (filter instanceof qlFunction) {
  578.         const d = filter.compileLokiJS()
  579.         if (d.needMatch) {
  580.           query.needMatch = true
  581.         }
  582.         delete d.needMatch
  583.         if (Object.keys(d).length) {
  584.           if (query.$and) {
  585.             query.$and.push(d)
  586.           } else {
  587.             query.$and = [d]
  588.           }
  589.         }
  590.       } else if (filter.op === '=') {
  591.         k = 'tags.' + filter.key
  592.         v = { $eq: filter.value }
  593.       } else if (filter.op === '!=') {
  594.         k = 'tags.' + filter.key
  595.         v = { $ne: filter.value }
  596.       } else if (filter.op === 'has_key') {
  597.         k = 'tags.' + filter.key
  598.         v = { $exists: true }
  599.       } else if (filter.op === 'not_exists') {
  600.         k = 'tags.' + filter.key
  601.         v = { $exists: false }
  602.       } else if (filter.op === 'has') {
  603.         k = 'tags.' + filter.key
  604.         v = { $regex: '^(.*;|)' + filter.value + '(|;.*)$' }
  605.       } else if ((filter.op === '~') || (filter.op === '~i')) {
  606.         k = 'tags.' + filter.key
  607.         v = { $regex: new RegExp(filter.value, (filter.op === '~i' ? 'i' : '')) }
  608.       } else if ((filter.op === '!~') || (filter.op === '!~i')) {
  609.         k = 'tags.' + filter.key
  610.         v = { $not: { $regex: new RegExp(filter.value, (filter.op === '!~i' ? 'i' : '')) } }
  611.       } else if (filter.op === 'strsearch') {
  612.         k = 'tags.' + filter.key
  613.         v = { $regex: new RegExp(strsearch2regexp(filter.value), 'i') }
  614.       } else if (filter.type) {
  615.         k = 'type'
  616.         v = { $eq: filter.type }
  617.       } else if (filter.or) {
  618.         orQueries.push(filter.or.map(p => {
  619.           const r = this.toLokijs(options, p)
  620.           if (r.needMatch) {
  621.             query.needMatch = true
  622.             delete r.needMatch
  623.           }
  624.           return r
  625.         }))
  626.       } else {
  627.         console.log('unknown filter', filter)
  628.       }
  630.       if (k && v) {
  631.         if (k === 'needMatch') {
  632.           query.needMatch = true
  633.         } else if (k in query) {
  634.           if (!('$and' in query[k])) {
  635.             query[k] = { $and: [query[k]] }
  636.           }
  637.           query[k].$and.push(v)
  638.         } else {
  639.           query[k] = v
  640.         }
  641.       }
  642.     })
  644.     orQueries = orQueries.filter(q => Object.keys(q).length)
  645.     if (orQueries.length === 1) {
  646.       query.$or = orQueries[0]
  647.     } else if (orQueries.length > 1) {
  648.       query.$and = orQueries.map(q => { return { $or: q } })
  649.     }
  651.     return query
  652.   }
  654.   cacheDescriptors () {
  655.     let result
  657.     if (Array.isArray(this.def) && Array.isArray(this.def[0])) {
  658.       // script with several statements detected. only compile the last one, as previous statements
  659.       // can't have an effect on the last statement yet.
  660.       result = this._caches(this.def[this.def.length - 1])
  661.     } else {
  662.       result = this._caches(this.def)
  663.     }
  665.     result.forEach(entry => {
  666.       entry.id = (entry.type || 'nwr') + entry.filters + '(properties:' + entry.properties + ')'
  667.       delete entry.type
  668.       delete entry.filters
  669.       delete entry.properties
  670.     })
  672.     return result
  673.   }
  675.   _caches (def) {
  676.     let options = [{ filters: '', properties: 0 }]
  678.     if (def.or) {
  679.       let result = []
  680.       def.or.forEach(e => {
  681.         const r = this._caches(e)
  682.         if (Array.isArray(r)) {
  683.           result = result.concat(r)
  684.         } else {
  685.           result.push(r)
  686.         }
  687.       })
  688.       return result
  689.     }
  691.     if (!Array.isArray(def)) {
  692.       def = [def]
  693.     }
  695.     def.forEach(part => {
  696.       if (part.type) {
  697.         options = options.map(o => {
  698.           if (o.type && o.type !== part.type) {
  699.             o.type = '-'
  700.           } else {
  701.             o.type = part.type
  702.           }
  703.           return o
  704.         })
  705.       } else if (part.op) {
  706.         options = options.map(o => {
  707.           o.filters += compile(part)
  708.           o.properties |= OverpassFrontend.TAGS
  709.           return o
  710.         })
  711.       } else if (part instanceof qlFunction) {
  712.         part.cacheDescriptors(options)
  713.       } else if (part.or) {
  714.         const result = []
  715.         part.or.forEach(e => {
  716.           const r = this._caches(e)
  718.           options.forEach(o => {
  719.             r.forEach(r1 => {
  720.               result.push(this._cacheMerge(o, r1))
  721.             })
  722.           })
  723.         })
  725.         options = result
  726.       } else if (part.and) {
  727.         let result = options
  728.         part.and.forEach(e => {
  729.           const current = result
  730.           result = []
  731.           const r = this._caches(e)
  732.           r.forEach(r1 => {
  733.             current.forEach(c => {
  734.               result.push(this._cacheMerge(c, r1))
  735.             })
  736.           })
  737.         })
  739.         options = result
  740.       } else {
  741.         throw new Error('caches(): invalid entry')
  742.       }
  743.     })
  745.     return options
  746.   }
  748.   _cacheMerge (a, b) {
  749.     const r = {}
  750.     for (const k in a) {
  751.       r[k] = a[k]
  752.     }
  753.     r.filters += b.filters
  754.     r.properties |= b.properties
  756.     if (b.type) {
  757.       if (a.type && a.type !== b.type) {
  758.         r.type = '-'
  759.       } else {
  760.         r.type = b.type
  761.       }
  762.     }
  764.     if (b.ids) {
  765.       r.ids = b.ids
  766.       if (a.ids) {
  767.         r.ids = b.ids.filter(n => a.ids.includes(n))
  768.       }
  769.     }
  771.     if (b.invalid) {
  772.       r.invalid = true
  773.     }
  775.     if (b.bounds && a.bounds) {
  776.       const mergeBounds = turf.intersect(a.bounds, b.bounds)
  777.       if (mergeBounds) {
  778.         r.bounds = mergeBounds.geometry
  779.       } else {
  780.         r.invalid = true
  781.         delete r.bounds
  782.       }
  783.     } else if (b.bounds) {
  784.       r.bounds = b.bounds
  785.     }
  787.     return r
  788.   }
  790.   /**
  791.    * compare this filter with an other filter.
  792.    * @param Filter other the other filter.
  793.    * @return boolean true, if the current filter is equal other or a super-set of other.
  794.    */
  795.   isSupersetOf (other) {
  796.     return this._isSupersetOf(this.def, other.def)
  797.   }
  799.   _isSupersetOf (def, otherDef) {
  800.     if (def.or) {
  801.       return def.or.some(d => this._isSupersetOf(d, otherDef))
  802.     }
  803.     if (def.and) {
  804.       return def.and.every(d => this._isSupersetOf(d, otherDef))
  805.     }
  807.     if (otherDef.or) {
  808.       return otherDef.or.every(d => this._isSupersetOf(def, d))
  809.     }
  810.     if (otherDef.and) {
  811.       return otherDef.and.some(d => this._isSupersetOf(def, d))
  812.     }
  814.     // search for something, where otherPart is not equal or subset
  815.     return !def.some(part => {
  816.       return !otherDef.some(otherPart => {
  817.         if (part.type && otherPart.type) {
  818.           return part.type === otherPart.type
  819.         }
  820.         if (compile(otherPart, { toString: true }) === compile(part, { toString: true })) {
  821.           return true
  822.         }
  823.         if (['~', '~i'].includes(part.op) && otherPart.op === '=' && part.key === otherPart.key && otherPart.value.match(RegExp(part.value, part.op === '~i' ? 'i' : ''))) {
  824.           return true
  825.         }
  826.         if (['~', '~i'].includes(part.op) && part.keyRegexp && otherPart.op === '=' && otherPart.key.match(RegExp(part.key, part.keyRegexp === 'i' ? 'i' : '')) && otherPart.value.match(RegExp(part.value, part.op === '~i' ? 'i' : ''))) {
  827.           return true
  828.         }
  829.         if (part.op === 'has_key' && otherPart.op && !['!=', '!~', '!~i', 'not_exists'].includes(otherPart.op) && part.key === otherPart.key) {
  830.           return true
  831.         }
  832.         if (part.op === 'has_key' && part.keyRegexp && otherPart.op && !['!=', '!~', '!~i', 'not_exists'].includes(otherPart.op) && otherPart.key.match(RegExp(part.key, part.keyRegexp === 'i' ? 'i' : ''))) {
  833.           return true
  834.         }
  835.         if (part instanceof qlFunction && otherPart instanceof qlFunction && part.isSupersetOf(otherPart)) {
  836.           return true
  837.         }
  838.         return false
  839.       })
  840.     })
  841.   }
  843.   /**
  844.    * @returns {number} properties which are required for this filter
  845.    */
  846.   properties () {
  847.     let result
  849.     if (Array.isArray(this.def) && Array.isArray(this.def[0])) {
  850.       // script with several statements detected. only compile the last one, as previous statements
  851.       // can't have an effect on the last statement yet.
  852.       result = this._caches(this.def[this.def.length - 1])
  853.     } else {
  854.       result = this._caches(this.def)
  855.     }
  857.     return result.reduce((current, entry) => current | entry.properties, 0)
  858.   }
  859. }
  861. module.exports = Filter