@ht-sdks/events-sdk-js-browser 1.4.0 → 1.5.0

package/dist/umd/tsub-middleware.bundle.59e8d6916920ab24b51c.js

@@ -0,0 +1,2 @@
+(self.webpackChunk_ht_sdks_events_sdk_js_browser=self.webpackChunk_ht_sdks_events_sdk_js_browser||[]).push([[604],{7843:function(r){r.exports=function(r,e,t,n,o){for(e=e.split?e.split("."):e,n=0;n<e.length;n++)r=r?r[e[n]]:o;return r===o?t:r}},6952:function(r,e,t){"use strict";t.r(e),t.d(e,{tsubMiddleware:function(){return _}});var n=function(){function r(r){this.rules=[],this.rules=r||[]}return r.prototype.getRulesByDestinationName=function(r){for(var e=[],t=0,n=this.rules;t<n.length;t++){var o=n[t];o.destinationName!==r&&void 0!==o.destinationName||e.push(o)}return e},r}(),o=t(7843),a=t.n(o);function i(r,e){if(!e)throw new Error("No matcher supplied!");switch(e.type){case"all":return!0;case"fql":return function(r,e){if(!r)return!1;try{r=JSON.parse(r)}catch(e){throw new Error('Failed to JSON.parse FQL intermediate representation "'.concat(r,'": ').concat(e))}var t=c(r,e);if("boolean"!=typeof t)return!1;return t}(e.ir,r);default:throw new Error("Matcher of type ".concat(e.type," unsupported."))}}function c(r,e){if(!Array.isArray(r))return!0===s(r,e);var t=r[0];switch(t){case"!":return!c(r[1],e);case"or":for(var n=1;n<r.length;n++)if(c(r[n],e))return!0;return!1;case"and":for(n=1;n<r.length;n++)if(!c(r[n],e))return!1;return!0;case"=":case"!=":return function(r,e,t,n){u(r)&&(r=c(r,n));u(e)&&(e=c(e,n));"object"==typeof r&&"object"==typeof e&&(r=JSON.stringify(r),e=JSON.stringify(e));switch(t){case"=":return r===e;case"!=":return r!==e;default:throw new Error("Invalid operator in compareItems: ".concat(t))}}(s(r[1],e),s(r[2],e),t,e);case"<=":case"<":case">":case">=":return function(r,e,t,n){u(r)&&(r=c(r,n));u(e)&&(e=c(e,n));if("number"!=typeof r||"number"!=typeof e)return!1;switch(t){case"<=":return r<=e;case">=":return r>=e;case"<":return r<e;case">":return r>e;default:throw new Error("Invalid operator in compareNumbers: ".concat(t))}}(s(r[1],e),s(r[2],e),t,e);case"in":return function(r,e,t){return void 0!==e.find((function(e){return s(e,t)===r}))}(s(r[1],e),s(r[2],e),e);case"contains":return function(r,e){if("string"!=typeof r||"string"!=typeof e)return!1;return-1!==r.indexOf(e)}(s(r[1],e),s(r[2],e));case"match":return function(r,e){if("string"!=typeof r||"string"!=typeof e)return!1;return function(r,e){var t,n;r:for(;r.length>0;){var o=void 0,a=void 0;if(o=(t=f(r)).star,a=t.chunk,r=t.pattern,o&&""===a)return!0;var i=l(a,e),c=i.t,s=i.ok,u=i.err;if(u)return!1;if(!s||!(0===c.length||r.length>0)){if(o)for(var p=0;p<e.length;p++){if(c=(n=l(a,e.slice(p+1))).t,s=n.ok,u=n.err,s){if(0===r.length&&c.length>0)continue;e=c;continue r}if(u)return!1}return!1}e=c}return 0===e.length}(e,r)}(s(r[1],e),s(r[2],e));case"lowercase":var o=s(r[1],e);return"string"!=typeof o?null:o.toLowerCase();case"typeof":return typeof s(r[1],e);case"length":return function(r){if(null===r)return 0;if(!Array.isArray(r)&&"string"!=typeof r)return NaN;return r.length}(s(r[1],e));default:throw new Error("FQL IR could not evaluate for token: ".concat(t))}}function s(r,e){return Array.isArray(r)?r:"object"==typeof r?r.value:a()(e,r)}function u(r){return!!Array.isArray(r)&&(("lowercase"===r[0]||"length"===r[0]||"typeof"===r[0])&&2===r.length||("contains"===r[0]||"match"===r[0])&&3===r.length)}function f(r){for(var e={star:!1,chunk:"",pattern:""};r.length>0&&"*"===r[0];)r=r.slice(1),e.star=!0;var t,n=!1;r:for(t=0;t<r.length;t++)switch(r[t]){case"\\":t+1<r.length&&t++;break;case"[":n=!0;break;case"]":n=!1;break;case"*":if(!n)break r}return e.chunk=r.slice(0,t),e.pattern=r.slice(t),e}function l(r,e){for(var t,n,o={t:"",ok:!1,err:!1};r.length>0;){if(0===e.length)return o;switch(r[0]){case"[":var a=e[0];e=e.slice(1);var i=!0;(r=r.slice(1)).length>0&&"^"===r[0]&&(i=!1,r=r.slice(1));for(var c=!1,s=0;;){if(r.length>0&&"]"===r[0]&&s>0){r=r.slice(1);break}var u,f="";if(u=(t=p(r)).char,r=t.newChunk,t.err)return o;if(f=u,"-"===r[0]&&(f=(n=p(r.slice(1))).char,r=n.newChunk,n.err))return o;u<=a&&a<=f&&(c=!0),s++}if(c!==i)return o;break;case"?":e=e.slice(1),r=r.slice(1);break;case"\\":if(0===(r=r.slice(1)).length)return o.err=!0,o;default:if(r[0]!==e[0])return o;e=e.slice(1),r=r.slice(1)}}return o.t=e,o.ok=!0,o.err=!1,o}function p(r){var e={char:"",newChunk:"",err:!1};return 0===r.length||"-"===r[0]||"]"===r[0]||"\\"===r[0]&&0===(r=r.slice(1)).length?(e.err=!0,e):(e.char=r[0],e.newChunk=r.slice(1),0===e.newChunk.length&&(e.err=!0),e)}var h=t(4791),v=t.n(h),g=t(380);function y(r,e){if(a()(r,e)){for(var t=e.split("."),n=t.pop();t.length&&"\\"===t[t.length-1].slice(-1);)n=t.pop().slice(0,-1)+"."+n;for(;t.length;)r=r[e=t.shift()];return delete r[n]}return!0}function d(r,e){for(var t=r,n=0,o=e;n<o.length;n++){var a=o[n];switch(a.type){case"drop":return null;case"drop_properties":w(t,a.config);break;case"allow_properties":b(t,a.config);break;case"sample_event":if(N(t,a.config))break;return null;case"map_properties":m(t,a.config);break;case"hash_properties":break;default:throw new Error('Transformer of type "'.concat(a.type,'" is unsupported.'))}}return t}function w(r,e){k(r,e.drop,(function(r,e){e.forEach((function(e){return delete r[e]}))}))}function b(r,e){k(r,e.allow,(function(r,e){Object.keys(r).forEach((function(t){e.includes(t)||delete r[t]}))}))}function k(r,e,t){Object.entries(e).forEach((function(e){var n=e[0],o=e[1],i=function(r){"object"==typeof r&&null!==r&&t(r,o)},c=""===n?r:a()(r,n);Array.isArray(c)?c.forEach(i):i(c)}))}function m(r,e){var t=JSON.parse(JSON.stringify(r));for(var n in e.map)if(Object.prototype.hasOwnProperty.call(e.map,n)){var o=e.map[n],i=n.split("."),c=void 0;if(i.length>1?(i.pop(),c=a()(t,i.join("."))):c=r,"object"==typeof c){if(o.copy){var s=a()(t,o.copy);void 0!==s&&(0,g.N)(r,n,s)}else if(o.move){var u=a()(t,o.move);void 0!==u&&(0,g.N)(r,n,u),y(r,o.move)}else Object.prototype.hasOwnProperty.call(o,"set")&&(0,g.N)(r,n,o.set);if(o.to_string){var f=a()(r,n);if("string"==typeof f||"object"==typeof f&&null!==f)continue;void 0!==f?(0,g.N)(r,n,JSON.stringify(f)):(0,g.N)(r,n,"undefined")}}}}function N(r,e){return!(e.sample.percent<=0)&&(e.sample.percent>=1||(e.sample.path?function(r,e){var t=a()(r,e.sample.path),n=v().hash(JSON.stringify(t)).match(/.{2}/g).map((function(r){return parseInt(r,16)})),o=-64,i=[];j(n.slice(0,8),i);for(var c=0,s=0;s<64&&1!==i[s];s++)c++;if(0!==c){var u=[];j(n.slice(9,16),u),o-=c,i.splice(0,c),u.splice(64-c),i=i.concat(u)}return i[63]=0===i[63]?1:0,function(r,e){return r*Math.pow(2,e)}(parseInt(i.join(""),2),o)<e.sample.percent}(r,e):(t=e.sample.percent,Math.random()<=t)));var t}function j(r,e){for(var t=0;t<8;t++)for(var n=r[t],o=128;o>=1;o/=2)n-o>=0?(n-=o,e.push(1)):e.push(0)}var _=function(r){return function(e){var t=e.payload,o=e.integration,a=e.next;new n(r).getRulesByDestinationName(o).forEach((function(r){for(var e=r.matchers,n=r.transformers,o=0;o<e.length;o++)if(i(t.obj,e[o])&&(t.obj=d(t.obj,n[o]),null===t.obj))return a(null)})),a(t)}}}}]);
+//# sourceMappingURL=tsub-middleware.bundle.59e8d6916920ab24b51c.js.map

package/dist/umd/tsub-middleware.bundle.59e8d6916920ab24b51c.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tsub-middleware.bundle.59e8d6916920ab24b51c.js","mappings":"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","sources":["webpack://@ht-sdks/events-sdk-js-browser/../../node_modules/dlv/dist/dlv.umd.js","webpack://@ht-sdks/events-sdk-js-browser/./src/lib/tsub/store.ts","webpack://@ht-sdks/events-sdk-js-browser/./src/lib/tsub/matchers.ts","webpack://@ht-sdks/events-sdk-js-browser/./src/lib/tsub/unset.ts","webpack://@ht-sdks/events-sdk-js-browser/./src/lib/tsub/transformers.ts","webpack://@ht-sdks/events-sdk-js-browser/./src/plugins/routing-middleware/index.ts"],"sourcesContent":["!function(t,n){\"object\"==typeof exports&&\"undefined\"!=typeof module?module.exports=function(t,n,e,i,o){for(n=n.split?n.split(\".\"):n,i=0;i<n.length;i++)t=t?t[n[i]]:o;return t===o?e:t}:\"function\"==typeof define&&define.amd?define(function(){return function(t,n,e,i,o){for(n=n.split?n.split(\".\"):n,i=0;i<n.length;i++)t=t?t[n[i]]:o;return t===o?e:t}}):t.dlv=function(t,n,e,i,o){for(n=n.split?n.split(\".\"):n,i=0;i<n.length;i++)t=t?t[n[i]]:o;return t===o?e:t}}(this);\n//# sourceMappingURL=dlv.umd.js.map\n","import { TransformerConfig } from './transformers'\n\nexport interface Rule {\n  scope: string\n  target_type: string\n  matchers: Matcher[]\n  transformers: Transformer[][]\n  destinationName?: string\n}\n\nexport interface Matcher {\n  type: string\n  ir: string\n}\n\nexport interface Transformer {\n  type: string\n  config?: TransformerConfig | null\n}\n\nexport default class Store {\n  private readonly rules: Rule[] = []\n\n  constructor(rules?: Rule[]) {\n    this.rules = rules || []\n  }\n\n  public getRulesByDestinationName(destinationName: string): Rule[] {\n    const rules: Rule[] = []\n    for (const rule of this.rules) {\n      // Rules with no destinationName are global (workspace || workspace::source)\n      if (\n        rule.destinationName === destinationName ||\n        rule.destinationName === undefined\n      ) {\n        rules.push(rule)\n      }\n    }\n\n    return rules\n  }\n}\n","import * as Store from './store'\nimport get from 'dlv'\n\ntype Event = Record<string, any>\n\nexport default function matches(event: Event, matcher: Store.Matcher): boolean {\n  if (!matcher) {\n    throw new Error('No matcher supplied!')\n  }\n\n  switch (matcher.type) {\n    case 'all':\n      return all()\n    case 'fql':\n      return fql(matcher.ir, event)\n    default:\n      throw new Error(`Matcher of type ${matcher.type} unsupported.`)\n  }\n}\n\nfunction all(): boolean {\n  return true\n}\n\nfunction fql(ir: Store.Matcher['ir'], event: Event): boolean {\n  if (!ir) {\n    return false\n  }\n\n  try {\n    ir = JSON.parse(ir)\n  } catch (e) {\n    throw new Error(\n      `Failed to JSON.parse FQL intermediate representation \"${ir}\": ${e}`\n    )\n  }\n\n  const result = fqlEvaluate(ir, event)\n  if (typeof result !== 'boolean') {\n    // An error was returned, or a lowercase, typeof, or similar function was run alone. Nothing to evaluate.\n    return false\n  }\n\n  return result\n}\n\n// FQL is 100% type strict in Go. Show no mercy to types which do not comply.\nfunction fqlEvaluate(ir: any, event: Event): any {\n  // If the given ir chunk is not an array, then we should check the single given path or value for literally `true`.\n  if (!Array.isArray(ir)) {\n    return getValue(ir, event) === true\n  }\n\n  // Otherwise, it is a sequence of ordered steps to follow to reach our solution!\n  const item = ir[0]\n  switch (item) {\n    /*** Unary cases ***/\n    // '!' => Invert the result\n    case '!':\n      return !fqlEvaluate(ir[1], event)\n\n    /*** Binary cases ***/\n    // 'or' => Any condition being true returns true\n    case 'or':\n      for (let i = 1; i < ir.length; i++) {\n        if (fqlEvaluate(ir[i], event)) {\n          return true\n        }\n      }\n      return false\n    // 'and' => Any condition being false returns false\n    case 'and':\n      for (let i = 1; i < ir.length; i++) {\n        if (!fqlEvaluate(ir[i], event)) {\n          return false\n        }\n      }\n      return true\n    // Equivalence comparisons\n    case '=':\n    case '!=':\n      return compareItems(\n        getValue(ir[1], event),\n        getValue(ir[2], event),\n        item,\n        event\n      )\n    // Numerical comparisons\n    case '<=':\n    case '<':\n    case '>':\n    case '>=':\n      // Compare the two values with the given operator.\n      return compareNumbers(\n        getValue(ir[1], event),\n        getValue(ir[2], event),\n        item,\n        event\n      )\n    // item in [list]' => Checks whether item is in list\n    case 'in':\n      return checkInList(getValue(ir[1], event), getValue(ir[2], event), event)\n\n    /*** Functions ***/\n    // 'contains(str1, str2)' => The first string has a substring of the second string\n    case 'contains':\n      return contains(getValue(ir[1], event), getValue(ir[2], event))\n    // 'match(str, match)' => The given string matches the provided glob matcher\n    case 'match':\n      return match(getValue(ir[1], event), getValue(ir[2], event))\n    // 'lowercase(str)' => Returns a lowercased string, null if the item is not a string\n    case 'lowercase': {\n      const target = getValue(ir[1], event)\n      if (typeof target !== 'string') {\n        return null\n      }\n      return target.toLowerCase()\n    }\n    // 'typeof(val)' => Returns the FQL type of the value\n    case 'typeof':\n      // TODO: Do we need mapping to allow for universal comparisons? e.g. Object -> JSON, Array -> List, Floats?\n      return typeof getValue(ir[1], event)\n    // 'length(val)' => Returns the length of an array or string, NaN if neither\n    case 'length':\n      return length(getValue(ir[1], event))\n    // If nothing hit, we or the IR messed up somewhere.\n    default:\n      throw new Error(`FQL IR could not evaluate for token: ${item}`)\n  }\n}\n\nfunction getValue(item: any, event: Event) {\n  // If item is an array, leave it as-is.\n  if (Array.isArray(item)) {\n    return item\n  }\n\n  // If item is an object, it has the form of `{\"value\": VAL}`\n  if (typeof item === 'object') {\n    return item.value\n  }\n\n  // Otherwise, it's an event path, e.g. \"properties.email\"\n  return get(event, item)\n}\n\nfunction checkInList(item: any, list: any[], event: Event): boolean {\n  return list.find((it) => getValue(it, event) === item) !== undefined\n}\n\nfunction compareNumbers(\n  first: any,\n  second: any,\n  operator: string,\n  event: Event\n): boolean {\n  // Check if it's more IR (such as a length() function)\n  if (isIR(first)) {\n    first = fqlEvaluate(first, event)\n  }\n\n  if (isIR(second)) {\n    second = fqlEvaluate(second, event)\n  }\n\n  if (typeof first !== 'number' || typeof second !== 'number') {\n    return false\n  }\n\n  // Reminder: NaN is not comparable to any other number (including NaN) and will always return false as desired.\n  switch (operator) {\n    // '<=' => The first number is less than or equal to the second.\n    case '<=':\n      return first <= second\n    // '>=' => The first number is greater than or equal to the second\n    case '>=':\n      return first >= second\n    // '<' The first number is less than the second.\n    case '<':\n      return first < second\n    // '>' The first number is greater than the second.\n    case '>':\n      return first > second\n    default:\n      throw new Error(`Invalid operator in compareNumbers: ${operator}`)\n  }\n}\n\nfunction compareItems(\n  first: any,\n  second: any,\n  operator: string,\n  event: Event\n): boolean {\n  // Check if it's more IR (such as a lowercase() function)\n  if (isIR(first)) {\n    first = fqlEvaluate(first, event)\n  }\n\n  if (isIR(second)) {\n    second = fqlEvaluate(second, event)\n  }\n\n  if (typeof first === 'object' && typeof second === 'object') {\n    first = JSON.stringify(first)\n    second = JSON.stringify(second)\n  }\n\n  // Objects with the exact same contents AND order ARE considered identical. (Don't compare by reference)\n  // Even in Go, this MUST be the same byte order.\n  // e.g. {a: 1, b:2} === {a: 1, b:2} BUT {a:1, b:2} !== {b:2, a:1}\n  // Maybe later we'll use a stable stringifier, but we're matching server-side behavior for now.\n  switch (operator) {\n    // '=' => The two following items are exactly identical\n    case '=':\n      return first === second\n    // '!=' => The two following items are NOT exactly identical.\n    case '!=':\n      return first !== second\n    default:\n      throw new Error(`Invalid operator in compareItems: ${operator}`)\n  }\n}\n\nfunction contains(first: any, second: any): boolean {\n  if (typeof first !== 'string' || typeof second !== 'string') {\n    return false\n  }\n\n  return first.indexOf(second) !== -1\n}\n\nfunction match(str: any, glob: any): boolean {\n  if (typeof str !== 'string' || typeof glob !== 'string') {\n    return false\n  }\n\n  return globMatches(glob, str)\n}\n\nfunction length(item: any) {\n  // Match server-side behavior.\n  if (item === null) {\n    return 0\n  }\n\n  // Type-check to avoid returning .length of an object\n  if (!Array.isArray(item) && typeof item !== 'string') {\n    return NaN\n  }\n\n  return item.length\n}\n\n// This is a heuristic technically speaking, but should be close enough. The odds of someone trying to test\n// a func with identical IR notation is pretty low.\nfunction isIR(value: any): boolean {\n  // TODO: This can be better checked by checking if this is a {\"value\": THIS}\n  if (!Array.isArray(value)) {\n    return false\n  }\n\n  // Function checks\n  if (\n    (value[0] === 'lowercase' ||\n      value[0] === 'length' ||\n      value[0] === 'typeof') &&\n    value.length === 2\n  ) {\n    return true\n  }\n\n  if ((value[0] === 'contains' || value[0] === 'match') && value.length === 3) {\n    return true\n  }\n\n  return false\n}\n\n// Any reputable glob matcher is designed to work on filesystems and doesn't allow the override of the separator\n// character \"/\". This is problematic since our server-side representation e.g. evaluates \"match('ab/c', 'a*)\"\n// as TRUE, whereas any glob matcher for JS available does false. So we're rewriting it here.\n// See: https://github.com/segmentio/glob/blob/master/glob.go\nfunction globMatches(pattern: string, str: string): boolean {\n  Pattern: while (pattern.length > 0) {\n    let star\n    let chunk\n    ;({ star, chunk, pattern } = scanChunk(pattern))\n    if (star && chunk === '') {\n      // Trailing * matches rest of string\n      return true\n    }\n\n    // Look for match at current position\n    let { t, ok, err } = matchChunk(chunk, str)\n    if (err) {\n      return false\n    }\n\n    // If we're the last chunk, make sure we've exhausted the str\n    // otherwise we'll give a false result even if we could still match\n    // using the star\n    if (ok && (t.length === 0 || pattern.length > 0)) {\n      str = t\n      continue\n    }\n\n    if (star) {\n      // Look for match, skipping i+1 bytes.\n      for (let i = 0; i < str.length; i++) {\n        ;({ t, ok, err } = matchChunk(chunk, str.slice(i + 1)))\n        if (ok) {\n          // If we're the last chunk, make sure we exhausted the str.\n          if (pattern.length === 0 && t.length > 0) {\n            continue\n          }\n\n          str = t\n          continue Pattern\n        }\n\n        if (err) {\n          return false\n        }\n      }\n    }\n\n    return false\n  }\n\n  return str.length === 0\n}\n\nfunction scanChunk(pattern: string): any {\n  const result = {\n    star: false,\n    chunk: '',\n    pattern: '',\n  }\n\n  while (pattern.length > 0 && pattern[0] === '*') {\n    pattern = pattern.slice(1)\n    result.star = true\n  }\n\n  let inRange = false\n  let i\n\n  Scan: for (i = 0; i < pattern.length; i++) {\n    switch (pattern[i]) {\n      case '\\\\':\n        // Error check handled in matchChunk: bad pattern.\n        if (i + 1 < pattern.length) {\n          i++\n        }\n        break\n      case '[':\n        inRange = true\n        break\n      case ']':\n        inRange = false\n        break\n      case '*':\n        if (!inRange) {\n          break Scan\n        }\n    }\n  }\n\n  result.chunk = pattern.slice(0, i)\n  result.pattern = pattern.slice(i)\n  return result\n}\n\n// matchChunk checks whether chunk matches the beginning of s.\n// If so, it returns the remainder of s (after the match).\n// Chunk is all single-character operators: literals, char classes, and ?.\nfunction matchChunk(chunk: string, str: string): any {\n  const result = {\n    t: '',\n    ok: false,\n    err: false,\n  }\n\n  while (chunk.length > 0) {\n    if (str.length === 0) {\n      return result\n    }\n\n    switch (chunk[0]) {\n      case '[': {\n        const char = str[0]\n        str = str.slice(1)\n        chunk = chunk.slice(1)\n\n        let notNegated = true\n        if (chunk.length > 0 && chunk[0] === '^') {\n          notNegated = false\n          chunk = chunk.slice(1)\n        }\n\n        // Parse all ranges\n        let foundMatch = false\n        let nRange = 0\n\n        // eslint-disable-next-line no-constant-condition\n        while (true) {\n          if (chunk.length > 0 && chunk[0] === ']' && nRange > 0) {\n            chunk = chunk.slice(1)\n            break\n          }\n\n          let lo = ''\n          let hi = ''\n          let err\n          ;({ char: lo, newChunk: chunk, err } = getEsc(chunk))\n          if (err) {\n            return result\n          }\n\n          hi = lo\n          if (chunk[0] === '-') {\n            ;({ char: hi, newChunk: chunk, err } = getEsc(chunk.slice(1)))\n            if (err) {\n              return result\n            }\n          }\n\n          if (lo <= char && char <= hi) {\n            foundMatch = true\n          }\n\n          nRange++\n        }\n\n        if (foundMatch !== notNegated) {\n          return result\n        }\n\n        break\n      }\n      case '?':\n        str = str.slice(1)\n        chunk = chunk.slice(1)\n        break\n      case '\\\\':\n        chunk = chunk.slice(1)\n        if (chunk.length === 0) {\n          result.err = true\n          return result\n        }\n      // Fallthrough, missing break intentional.\n      default:\n        if (chunk[0] !== str[0]) {\n          return result\n        }\n        str = str.slice(1)\n        chunk = chunk.slice(1)\n    }\n  }\n\n  result.t = str\n  result.ok = true\n  result.err = false\n  return result\n}\n\n// getEsc gets a possibly-escaped character from chunk, for a character class.\nfunction getEsc(chunk: string): any {\n  const result = {\n    char: '',\n    newChunk: '',\n    err: false,\n  }\n\n  if (chunk.length === 0 || chunk[0] === '-' || chunk[0] === ']') {\n    result.err = true\n    return result\n  }\n\n  if (chunk[0] === '\\\\') {\n    chunk = chunk.slice(1)\n    if (chunk.length === 0) {\n      result.err = true\n      return result\n    }\n  }\n\n  // Unlike Go, JS strings operate on characters instead of bytes.\n  // This is why we aren't copying over the GetRuneFromString stuff.\n  result.char = chunk[0]\n  result.newChunk = chunk.slice(1)\n  if (result.newChunk.length === 0) {\n    result.err = true\n  }\n\n  return result\n}\n","import get from 'dlv'\n\nexport function unset(obj: any, prop: any) {\n  if (get(obj, prop)) {\n    const segs = prop.split('.')\n    let last = segs.pop()\n    while (segs.length && segs[segs.length - 1].slice(-1) === '\\\\') {\n      last = segs.pop().slice(0, -1) + '.' + last\n    }\n    while (segs.length) obj = obj[(prop = segs.shift())]\n    return delete obj[last]\n  }\n  return true\n}\n","import { Transformer } from './store'\nimport MD5 from 'spark-md5'\nimport get from 'dlv'\nimport { dset } from 'dset'\nimport { unset } from './unset'\n\nexport type KeyTarget = Record<string, string[]>\n\nexport interface TransformerConfig {\n  allow?: KeyTarget\n  drop?: KeyTarget\n  sample?: TransformerConfigSample\n  map?: Record<string, TransformerConfigMap>\n}\n\nexport interface TransformerConfigSample {\n  percent: number\n  path: string\n}\n\nexport interface TransformerConfigMap {\n  set?: any\n  copy?: string\n  move?: string\n  to_string?: boolean\n}\n\nexport default function transform(\n  payload: any,\n  transformers: Transformer[]\n): any {\n  const transformedPayload = payload\n\n  for (const transformer of transformers) {\n    switch (transformer.type) {\n      case 'drop':\n        return null\n      case 'drop_properties':\n        dropProperties(transformedPayload, transformer.config!)\n        break\n      case 'allow_properties':\n        allowProperties(transformedPayload, transformer.config!)\n        break\n      case 'sample_event':\n        if (sampleEvent(transformedPayload, transformer.config!)) {\n          break\n        }\n        return null\n      case 'map_properties':\n        mapProperties(transformedPayload, transformer.config!)\n        break\n      case 'hash_properties':\n        // Not yet supported, but don't throw an error. Just ignore.\n        break\n      default:\n        throw new Error(\n          `Transformer of type \"${transformer.type}\" is unsupported.`\n        )\n    }\n  }\n\n  return transformedPayload\n}\n\n// dropProperties removes all specified props from the object.\nfunction dropProperties(payload: any, config: TransformerConfig) {\n  filterProperties(payload, config.drop!, (matchedObj, dropList) => {\n    dropList.forEach((k) => delete matchedObj[k])\n  })\n}\n\n// allowProperties ONLY allows the specific targets within the keys. (e.g. \"a.foo\": [\"bar\", \"baz\"]\n// on {a: {foo: {bar: 1, baz: 2}, other: 3}} will not have any drops, as it only looks inside a.foo\nfunction allowProperties(payload: any, config: TransformerConfig) {\n  filterProperties(payload, config.allow!, (matchedObj, preserveList) => {\n    Object.keys(matchedObj).forEach((key) => {\n      if (!preserveList.includes(key)) {\n        delete matchedObj[key]\n      }\n    })\n  })\n}\n\nfunction filterProperties(\n  payload: any,\n  ruleSet: KeyTarget,\n  filterCb: (matchedObject: any, targets: string[]) => void\n) {\n  Object.entries(ruleSet).forEach(([key, targets]) => {\n    const filter = (obj: any) => {\n      // Can only act on objects.\n      if (typeof obj !== 'object' || obj === null) {\n        return\n      }\n\n      filterCb(obj, targets)\n    }\n\n    // If key is empty, it refers to the top-level object.\n    const matchedObject = key === '' ? payload : get(payload, key)\n\n    if (Array.isArray(matchedObject)) {\n      matchedObject.forEach(filter)\n    } else {\n      filter(matchedObject)\n    }\n  })\n}\n\nfunction mapProperties(payload: any, config: TransformerConfig) {\n  // Some configs might try to modify or read from a field multiple times. We will only ever read\n  // values as they were before any modifications began. Thus, if you try to override e.g.\n  // {a: {b: 1}} with set(a, 'b', 2) (which results in {a: {b: 2}}) and then try to copy a.b into\n  // a.c, you will get {a: {b: 2, c:1}} and NOT {a: {b:2, c:2}}. This prevents map evaluation\n  // order from mattering, and === what server-side does.\n  // See: https://github.com/segmentio/tsub/blob/661695a63b60b90471796e667458f076af788c19/transformers/map_properties.go#L179-L200\n  const initialPayload = JSON.parse(JSON.stringify(payload))\n\n  for (const key in config.map) {\n    if (!Object.prototype.hasOwnProperty.call(config.map, key)) {\n      continue\n    }\n\n    const actionMap: TransformerConfigMap = config.map[key]\n\n    // Can't manipulate non-objects. Check that the parent is one. Strip the last .field\n    // from the string.\n    const splitKey = key.split('.')\n    let parent\n    if (splitKey.length > 1) {\n      splitKey.pop()\n      parent = get(initialPayload, splitKey.join('.'))\n    } else {\n      parent = payload\n    }\n\n    if (typeof parent !== 'object') {\n      continue\n    }\n\n    // These actions are exclusive to each other.\n    if (actionMap.copy) {\n      const valueToCopy = get(initialPayload, actionMap.copy)\n      if (valueToCopy !== undefined) {\n        dset(payload, key, valueToCopy)\n      }\n    } else if (actionMap.move) {\n      const valueToMove = get(initialPayload, actionMap.move)\n      if (valueToMove !== undefined) {\n        dset(payload, key, valueToMove)\n      }\n\n      unset(payload, actionMap.move)\n    }\n    // Have to check only if property exists, as null, undefined, and other vals could be explicitly set.\n    else if (Object.prototype.hasOwnProperty.call(actionMap, 'set')) {\n      dset(payload, key, actionMap.set)\n    }\n\n    // to_string is not exclusive and can be paired with other actions. Final action.\n    if (actionMap.to_string) {\n      const valueToString = get(payload, key)\n\n      // Do not string arrays and objects. Do not double-encode strings.\n      if (\n        typeof valueToString === 'string' ||\n        (typeof valueToString === 'object' && valueToString !== null)\n      ) {\n        continue\n      }\n\n      // TODO: Check stringifier in Golang for parity.\n      if (valueToString !== undefined) {\n        dset(payload, key, JSON.stringify(valueToString))\n      } else {\n        // TODO: Check this behavior.\n        dset(payload, key, 'undefined')\n      }\n    }\n  }\n}\n\nfunction sampleEvent(payload: any, config: TransformerConfig): boolean {\n  if (config.sample!.percent <= 0) {\n    return false\n  } else if (config.sample!.percent >= 1) {\n    return true\n  }\n\n  // If we're not filtering deterministically, just use raw percentage.\n  if (!config.sample!.path) {\n    return samplePercent(config.sample!.percent)\n  }\n\n  // Otherwise, use a deterministic hash.\n  return sampleConsistentPercent(payload, config)\n}\n\nfunction samplePercent(percent: number): boolean {\n  // Math.random returns [0, 1) => 0.0<>0.9999...\n  return Math.random() <= percent\n}\n\n// sampleConsistentPercent converts an input string of bytes into a consistent uniform\n// continuous distribution of [0.0, 1.0]. This is based on\n// http://mumble.net/~campbell/tmp/random_real.c, but using the digest\n// result of the input value as the random information.\n\n// IMPORTANT - This function needs to === the Golang implementation to ensure that the two return the same vals!\n// See: https://github.com/segmentio/sampler/blob/65cb04132305a04fcd4bcaef67d57fbe40c30241/sampler.go#L13-L38\n\n// Since AJS supports IE9+ (typed arrays were introduced in IE10) we're doing some manual array math.\n// This could be done directly with strings, but arrays are easier to reason about/have better function support.\nfunction sampleConsistentPercent(\n  payload: any,\n  config: TransformerConfig\n): boolean {\n  const field = get(payload, config.sample!.path)\n\n  const hash = MD5.hash(JSON.stringify(field))\n  // convert hash to byte array\n  const digest = hash.match(/.{2}/g)!.map((byte) => parseInt(byte, 16))\n\n  let exponent = -64\n\n  // Manually maintain 64-bit int as an array.\n  let significand: number[] = []\n\n  // Left-shift and OR for first 8 bytes of digest. (8 bytes * 8 = 64 bits)\n  consumeDigest(digest.slice(0, 8), significand)\n\n  let leadingZeros = 0\n  for (let i = 0; i < 64; i++) {\n    if (significand[i] === 1) {\n      break\n    }\n\n    leadingZeros++\n  }\n\n  if (leadingZeros !== 0) {\n    // Use the last 8 bytes of the digest, same as before.\n    const val: number[] = []\n    consumeDigest(digest.slice(9, 16), val)\n\n    exponent -= leadingZeros\n    // Left-shift away leading zeros in significand.\n    significand.splice(0, leadingZeros)\n\n    // Right-shift val by 64 minus leading zeros and push into significand.\n    val.splice(64 - leadingZeros)\n    significand = significand.concat(val)\n  }\n\n  // Flip 64th bit\n  significand[63] = significand[63] === 0 ? 1 : 0\n\n  // Convert our manual binary into a JS num (binary arr => binary string => psuedo-int) and run the ldexp!\n  return (\n    ldexp(parseInt(significand.join(''), 2), exponent) < config.sample!.percent\n  )\n}\n\n// Array byte filler helper\nfunction consumeDigest(digest: number[], arr: number[]) {\n  for (let i = 0; i < 8; i++) {\n    let remainder = digest[i]\n    for (let binary = 128; binary >= 1; binary /= 2) {\n      if (remainder - binary >= 0) {\n        remainder -= binary\n        arr.push(1)\n      } else {\n        arr.push(0)\n      }\n    }\n  }\n}\n\n// Simplified implementation of https://github.com/stdlib-js/math-base-special-ldexp\nfunction ldexp(x: number, exp: number) {\n  return x * Math.pow(2, exp)\n}\n","import * as tsub from '../../lib/tsub'\nimport { DestinationMiddlewareFunction } from '../middleware'\n\n// TODO: update tsub definition\ntype RoutingRuleMatcher = tsub.Matcher & {\n  config?: {\n    expr: string\n  }\n}\n\nexport type RoutingRule = tsub.Rule & {\n  matchers: RoutingRuleMatcher[]\n}\n\nexport const tsubMiddleware =\n  (rules: RoutingRule[]): DestinationMiddlewareFunction =>\n  ({ payload, integration, next }): void => {\n    const store = new tsub.Store(rules)\n    const rulesToApply = store.getRulesByDestinationName(integration)\n\n    rulesToApply.forEach((rule) => {\n      const { matchers, transformers } = rule\n\n      for (let i = 0; i < matchers.length; i++) {\n        if (tsub.matches(payload.obj, matchers[i])) {\n          payload.obj = tsub.transform(payload.obj, transformers[i])\n\n          if (payload.obj === null) {\n            return next(null)\n          }\n        }\n      }\n    })\n\n    next(payload)\n  }\n"],"names":["module","exports","t","n","e","i","o","split","length","rules","this","getRulesByDestinationName","destinationName","rule","undefined","push","matches","event","matcher","Error","type","ir","JSON","parse","result","fqlEvaluate","fql","Array","isArray","getValue","item","first","second","operator","isIR","stringify","compareItems","compareNumbers","list","find","it","checkInList","indexOf","contains","str","glob","pattern","Pattern","star","chunk","scanChunk","matchChunk","ok","err","slice","globMatches","match","target","toLowerCase","NaN","value","inRange","Scan","char","notNegated","foundMatch","nRange","lo","hi","getEsc","newChunk","unset","obj","prop","segs","last","pop","shift","transform","payload","transformers","transformedPayload","transformer","dropProperties","config","allowProperties","sampleEvent","mapProperties","filterProperties","drop","matchedObj","dropList","forEach","k","allow","preserveList","Object","keys","key","includes","ruleSet","filterCb","entries","targets","filter","matchedObject","initialPayload","map","prototype","hasOwnProperty","call","actionMap","splitKey","parent","join","copy","valueToCopy","move","valueToMove","set","to_string","valueToString","sample","percent","path","field","digest","byte","parseInt","exponent","significand","consumeDigest","leadingZeros","val","splice","concat","x","exp","Math","pow","ldexp","sampleConsistentPercent","random","arr","remainder","binary","tsubMiddleware","integration","next","matchers"],"sourceRoot":""}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ht-sdks/events-sdk-js-browser",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/ht-sdks/events-sdk-js-mono",
@@ -49,7 +49,7 @@
     "@lukeed/uuid": "^2.0.0",
     "@segment/analytics.js-video-plugins": "^0.2.1",
     "@segment/facade": "^3.4.9",
-    "@segment/tsub": "^2.0.0",
+    "dlv": "^1.1.3",
     "dset": "^3.1.2",
     "js-cookie": "3.0.1",
     "node-fetch": "^2.6.7",
@@ -63,6 +63,7 @@
     "@segment/analytics.js-integration": "^3.3.3",
     "@segment/analytics.js-integration-amplitude": "^3.3.3",
     "@size-limit/preset-big-lib": "^7.0.8",
+    "@types/dlv": "^1.1.5",
     "@types/flat": "^5.0.1",
     "@types/fs-extra": "^9.0.2",
     "@types/jest-dev-server": "^5.0.0",

package/src/generated/version.ts

@@ -1,2 +1,2 @@
 // This file is generated.
-export const version = '1.4.0'
+export const version = '1.5.0'

package/src/lib/tsub/README.md

@@ -0,0 +1,9 @@
+Vendored from https://github.com/segmentio/tsub-js/tree/9771d565c92b78d0aec90a1f994a7e96ec86c330
+
+### Changes Made
+After cloning the original repo, we made the following changes:
+- Updated files to use proper TypeScript (mainly cleaning up/fixing type defs)
+- Removed dependency on `@stdlib/math-base-special-ldexp`
+   - Replaced with local implementation
+- Removed dependency on `tiny-hashes`
+   - Replaced with `spark-md5` (package which this repo already uses)

package/src/lib/tsub/index.ts

@@ -0,0 +1,3 @@
+export { default as transform } from './transformers'
+export { default as matches } from './matchers'
+export { default as Store, type Matcher, type Rule } from './store'

package/src/lib/tsub/matchers.ts

@@ -0,0 +1,498 @@
+import * as Store from './store'
+import get from 'dlv'
+
+type Event = Record<string, any>
+
+export default function matches(event: Event, matcher: Store.Matcher): boolean {
+  if (!matcher) {
+    throw new Error('No matcher supplied!')
+  }
+
+  switch (matcher.type) {
+    case 'all':
+      return all()
+    case 'fql':
+      return fql(matcher.ir, event)
+    default:
+      throw new Error(`Matcher of type ${matcher.type} unsupported.`)
+  }
+}
+
+function all(): boolean {
+  return true
+}
+
+function fql(ir: Store.Matcher['ir'], event: Event): boolean {
+  if (!ir) {
+    return false
+  }
+
+  try {
+    ir = JSON.parse(ir)
+  } catch (e) {
+    throw new Error(
+      `Failed to JSON.parse FQL intermediate representation "${ir}": ${e}`
+    )
+  }
+
+  const result = fqlEvaluate(ir, event)
+  if (typeof result !== 'boolean') {
+    // An error was returned, or a lowercase, typeof, or similar function was run alone. Nothing to evaluate.
+    return false
+  }
+
+  return result
+}
+
+// FQL is 100% type strict in Go. Show no mercy to types which do not comply.
+function fqlEvaluate(ir: any, event: Event): any {
+  // If the given ir chunk is not an array, then we should check the single given path or value for literally `true`.
+  if (!Array.isArray(ir)) {
+    return getValue(ir, event) === true
+  }
+
+  // Otherwise, it is a sequence of ordered steps to follow to reach our solution!
+  const item = ir[0]
+  switch (item) {
+    /*** Unary cases ***/
+    // '!' => Invert the result
+    case '!':
+      return !fqlEvaluate(ir[1], event)
+
+    /*** Binary cases ***/
+    // 'or' => Any condition being true returns true
+    case 'or':
+      for (let i = 1; i < ir.length; i++) {
+        if (fqlEvaluate(ir[i], event)) {
+          return true
+        }
+      }
+      return false
+    // 'and' => Any condition being false returns false
+    case 'and':
+      for (let i = 1; i < ir.length; i++) {
+        if (!fqlEvaluate(ir[i], event)) {
+          return false
+        }
+      }
+      return true
+    // Equivalence comparisons
+    case '=':
+    case '!=':
+      return compareItems(
+        getValue(ir[1], event),
+        getValue(ir[2], event),
+        item,
+        event
+      )
+    // Numerical comparisons
+    case '<=':
+    case '<':
+    case '>':
+    case '>=':
+      // Compare the two values with the given operator.
+      return compareNumbers(
+        getValue(ir[1], event),
+        getValue(ir[2], event),
+        item,
+        event
+      )
+    // item in [list]' => Checks whether item is in list
+    case 'in':
+      return checkInList(getValue(ir[1], event), getValue(ir[2], event), event)
+
+    /*** Functions ***/
+    // 'contains(str1, str2)' => The first string has a substring of the second string
+    case 'contains':
+      return contains(getValue(ir[1], event), getValue(ir[2], event))
+    // 'match(str, match)' => The given string matches the provided glob matcher
+    case 'match':
+      return match(getValue(ir[1], event), getValue(ir[2], event))
+    // 'lowercase(str)' => Returns a lowercased string, null if the item is not a string
+    case 'lowercase': {
+      const target = getValue(ir[1], event)
+      if (typeof target !== 'string') {
+        return null
+      }
+      return target.toLowerCase()
+    }
+    // 'typeof(val)' => Returns the FQL type of the value
+    case 'typeof':
+      // TODO: Do we need mapping to allow for universal comparisons? e.g. Object -> JSON, Array -> List, Floats?
+      return typeof getValue(ir[1], event)
+    // 'length(val)' => Returns the length of an array or string, NaN if neither
+    case 'length':
+      return length(getValue(ir[1], event))
+    // If nothing hit, we or the IR messed up somewhere.
+    default:
+      throw new Error(`FQL IR could not evaluate for token: ${item}`)
+  }
+}
+
+function getValue(item: any, event: Event) {
+  // If item is an array, leave it as-is.
+  if (Array.isArray(item)) {
+    return item
+  }
+
+  // If item is an object, it has the form of `{"value": VAL}`
+  if (typeof item === 'object') {
+    return item.value
+  }
+
+  // Otherwise, it's an event path, e.g. "properties.email"
+  return get(event, item)
+}
+
+function checkInList(item: any, list: any[], event: Event): boolean {
+  return list.find((it) => getValue(it, event) === item) !== undefined
+}
+
+function compareNumbers(
+  first: any,
+  second: any,
+  operator: string,
+  event: Event
+): boolean {
+  // Check if it's more IR (such as a length() function)
+  if (isIR(first)) {
+    first = fqlEvaluate(first, event)
+  }
+
+  if (isIR(second)) {
+    second = fqlEvaluate(second, event)
+  }
+
+  if (typeof first !== 'number' || typeof second !== 'number') {
+    return false
+  }
+
+  // Reminder: NaN is not comparable to any other number (including NaN) and will always return false as desired.
+  switch (operator) {
+    // '<=' => The first number is less than or equal to the second.
+    case '<=':
+      return first <= second
+    // '>=' => The first number is greater than or equal to the second
+    case '>=':
+      return first >= second
+    // '<' The first number is less than the second.
+    case '<':
+      return first < second
+    // '>' The first number is greater than the second.
+    case '>':
+      return first > second
+    default:
+      throw new Error(`Invalid operator in compareNumbers: ${operator}`)
+  }
+}
+
+function compareItems(
+  first: any,
+  second: any,
+  operator: string,
+  event: Event
+): boolean {
+  // Check if it's more IR (such as a lowercase() function)
+  if (isIR(first)) {
+    first = fqlEvaluate(first, event)
+  }
+
+  if (isIR(second)) {
+    second = fqlEvaluate(second, event)
+  }
+
+  if (typeof first === 'object' && typeof second === 'object') {
+    first = JSON.stringify(first)
+    second = JSON.stringify(second)
+  }
+
+  // Objects with the exact same contents AND order ARE considered identical. (Don't compare by reference)
+  // Even in Go, this MUST be the same byte order.
+  // e.g. {a: 1, b:2} === {a: 1, b:2} BUT {a:1, b:2} !== {b:2, a:1}
+  // Maybe later we'll use a stable stringifier, but we're matching server-side behavior for now.
+  switch (operator) {
+    // '=' => The two following items are exactly identical
+    case '=':
+      return first === second
+    // '!=' => The two following items are NOT exactly identical.
+    case '!=':
+      return first !== second
+    default:
+      throw new Error(`Invalid operator in compareItems: ${operator}`)
+  }
+}
+
+function contains(first: any, second: any): boolean {
+  if (typeof first !== 'string' || typeof second !== 'string') {
+    return false
+  }
+
+  return first.indexOf(second) !== -1
+}
+
+function match(str: any, glob: any): boolean {
+  if (typeof str !== 'string' || typeof glob !== 'string') {
+    return false
+  }
+
+  return globMatches(glob, str)
+}
+
+function length(item: any) {
+  // Match server-side behavior.
+  if (item === null) {
+    return 0
+  }
+
+  // Type-check to avoid returning .length of an object
+  if (!Array.isArray(item) && typeof item !== 'string') {
+    return NaN
+  }
+
+  return item.length
+}
+
+// This is a heuristic technically speaking, but should be close enough. The odds of someone trying to test
+// a func with identical IR notation is pretty low.
+function isIR(value: any): boolean {
+  // TODO: This can be better checked by checking if this is a {"value": THIS}
+  if (!Array.isArray(value)) {
+    return false
+  }
+
+  // Function checks
+  if (
+    (value[0] === 'lowercase' ||
+      value[0] === 'length' ||
+      value[0] === 'typeof') &&
+    value.length === 2
+  ) {
+    return true
+  }
+
+  if ((value[0] === 'contains' || value[0] === 'match') && value.length === 3) {
+    return true
+  }
+
+  return false
+}
+
+// Any reputable glob matcher is designed to work on filesystems and doesn't allow the override of the separator
+// character "/". This is problematic since our server-side representation e.g. evaluates "match('ab/c', 'a*)"
+// as TRUE, whereas any glob matcher for JS available does false. So we're rewriting it here.
+// See: https://github.com/segmentio/glob/blob/master/glob.go
+function globMatches(pattern: string, str: string): boolean {
+  Pattern: while (pattern.length > 0) {
+    let star
+    let chunk
+    ;({ star, chunk, pattern } = scanChunk(pattern))
+    if (star && chunk === '') {
+      // Trailing * matches rest of string
+      return true
+    }
+
+    // Look for match at current position
+    let { t, ok, err } = matchChunk(chunk, str)
+    if (err) {
+      return false
+    }
+
+    // If we're the last chunk, make sure we've exhausted the str
+    // otherwise we'll give a false result even if we could still match
+    // using the star
+    if (ok && (t.length === 0 || pattern.length > 0)) {
+      str = t
+      continue
+    }
+
+    if (star) {
+      // Look for match, skipping i+1 bytes.
+      for (let i = 0; i < str.length; i++) {
+        ;({ t, ok, err } = matchChunk(chunk, str.slice(i + 1)))
+        if (ok) {
+          // If we're the last chunk, make sure we exhausted the str.
+          if (pattern.length === 0 && t.length > 0) {
+            continue
+          }
+
+          str = t
+          continue Pattern
+        }
+
+        if (err) {
+          return false
+        }
+      }
+    }
+
+    return false
+  }
+
+  return str.length === 0
+}
+
+function scanChunk(pattern: string): any {
+  const result = {
+    star: false,
+    chunk: '',
+    pattern: '',
+  }
+
+  while (pattern.length > 0 && pattern[0] === '*') {
+    pattern = pattern.slice(1)
+    result.star = true
+  }
+
+  let inRange = false
+  let i
+
+  Scan: for (i = 0; i < pattern.length; i++) {
+    switch (pattern[i]) {
+      case '\\':
+        // Error check handled in matchChunk: bad pattern.
+        if (i + 1 < pattern.length) {
+          i++
+        }
+        break
+      case '[':
+        inRange = true
+        break
+      case ']':
+        inRange = false
+        break
+      case '*':
+        if (!inRange) {
+          break Scan
+        }
+    }
+  }
+
+  result.chunk = pattern.slice(0, i)
+  result.pattern = pattern.slice(i)
+  return result
+}
+
+// matchChunk checks whether chunk matches the beginning of s.
+// If so, it returns the remainder of s (after the match).
+// Chunk is all single-character operators: literals, char classes, and ?.
+function matchChunk(chunk: string, str: string): any {
+  const result = {
+    t: '',
+    ok: false,
+    err: false,
+  }
+
+  while (chunk.length > 0) {
+    if (str.length === 0) {
+      return result
+    }
+
+    switch (chunk[0]) {
+      case '[': {
+        const char = str[0]
+        str = str.slice(1)
+        chunk = chunk.slice(1)
+
+        let notNegated = true
+        if (chunk.length > 0 && chunk[0] === '^') {
+          notNegated = false
+          chunk = chunk.slice(1)
+        }
+
+        // Parse all ranges
+        let foundMatch = false
+        let nRange = 0
+
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+          if (chunk.length > 0 && chunk[0] === ']' && nRange > 0) {
+            chunk = chunk.slice(1)
+            break
+          }
+
+          let lo = ''
+          let hi = ''
+          let err
+          ;({ char: lo, newChunk: chunk, err } = getEsc(chunk))
+          if (err) {
+            return result
+          }
+
+          hi = lo
+          if (chunk[0] === '-') {
+            ;({ char: hi, newChunk: chunk, err } = getEsc(chunk.slice(1)))
+            if (err) {
+              return result
+            }
+          }
+
+          if (lo <= char && char <= hi) {
+            foundMatch = true
+          }
+
+          nRange++
+        }
+
+        if (foundMatch !== notNegated) {
+          return result
+        }
+
+        break
+      }
+      case '?':
+        str = str.slice(1)
+        chunk = chunk.slice(1)
+        break
+      case '\\':
+        chunk = chunk.slice(1)
+        if (chunk.length === 0) {
+          result.err = true
+          return result
+        }
+      // Fallthrough, missing break intentional.
+      default:
+        if (chunk[0] !== str[0]) {
+          return result
+        }
+        str = str.slice(1)
+        chunk = chunk.slice(1)
+    }
+  }
+
+  result.t = str
+  result.ok = true
+  result.err = false
+  return result
+}
+
+// getEsc gets a possibly-escaped character from chunk, for a character class.
+function getEsc(chunk: string): any {
+  const result = {
+    char: '',
+    newChunk: '',
+    err: false,
+  }
+
+  if (chunk.length === 0 || chunk[0] === '-' || chunk[0] === ']') {
+    result.err = true
+    return result
+  }
+
+  if (chunk[0] === '\\') {
+    chunk = chunk.slice(1)
+    if (chunk.length === 0) {
+      result.err = true
+      return result
+    }
+  }
+
+  // Unlike Go, JS strings operate on characters instead of bytes.
+  // This is why we aren't copying over the GetRuneFromString stuff.
+  result.char = chunk[0]
+  result.newChunk = chunk.slice(1)
+  if (result.newChunk.length === 0) {
+    result.err = true
+  }
+
+  return result
+}