working rss feed to nostr publish

node_modules/light-bolt11-decoder/examples/build.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+
+const esbuild = require('esbuild')
+const nodeGlobals = require('@esbuild-plugins/node-globals-polyfill').default
+
+esbuild
+  .build({
+    entryPoints: ['demo.jsx'],
+    outfile: 'demo.build.js',
+    bundle: true,
+    plugins: [nodeGlobals({buffer: true})],
+    define: {
+      window: 'self',
+      global: 'self'
+    },
+    sourcemap: 'inline'
+  })
+  .then(() => console.log('build success.'))

node_modules/light-bolt11-decoder/examples/demo.jsx

@@ -0,0 +1,121 @@
+import {decode} from 'light-bolt11-decoder'
+import React, {useState} from 'react'
+import {render} from 'react-dom'
+import useComputedState from 'use-computed-state'
+import styled, {css} from 'styled-components'
+
+const TAGCOLORS = {
+  lightning_network: 'rgb(31, 31, 40)',
+  coin_network: 'rgb(27, 51, 93)',
+  amount: 'rgb(0, 110, 98)',
+  separator: 'rgb(31, 31, 40)',
+  timestamp: 'rgb(181, 10, 11)',
+  payment_hash: 'rgb(71, 105, 169)',
+  description: 'rgb(41, 131, 11)',
+  description_hash: 'rgb(41, 131, 11)',
+  payment_secret: 'rgb(92, 25, 75)',
+  expiry: 'rgb(181, 10, 11)',
+  metadata: 'rgb(86, 25, 24)',
+  feature_bits: 'rgb(57, 118, 179)',
+  payee: 'rgb(51, 44, 138)',
+  unknown_tag: 'rgb(37, 15, 45)',
+  min_final_cltv_expiry: 'rgb(119, 34, 32)',
+  fallback_address: 'rgb(27, 51, 93)',
+  route_hint: 'rgb(131, 93, 233)',
+  signature: 'rgb(51, 44, 138)',
+  checksum: 'rgb(31, 31, 40)'
+}
+
+function getTagColor(name) {
+  return TAGCOLORS[name] || 'rgb(0, 0, 0)'
+}
+
+const Textarea = styled.textarea`
+  margin: 18px;
+  width: 90%;
+  height: 80px;
+`
+
+const Row = styled.div``
+
+const PaymentRequest = styled.div`
+  white-space: pre-wrap;
+  word-wrap: break-word;
+  word-break: break-all;
+`
+
+const Section = styled.span`
+  font-family: monospace;
+  font-size: 25px;
+
+  ${props => {
+    console.log(props)
+
+    return css`
+      background-color: ${getTagColor(props.name)
+        .replace('rgb', 'rgba')
+        .replace(')', ', 0.2)')};
+    `
+  }}
+
+  &:hover {
+    color: white;
+
+    ${props =>
+      css`
+        background-color: ${getTagColor(props.name)};
+      `}
+  }
+`
+
+const Info = styled.div`
+  margin: 8px;
+  padding: 8px;
+  color: white;
+
+  ${props =>
+    css`
+      background-color: ${getTagColor(props.name)};
+    `}
+`
+
+function Demo() {
+  const [pr, setPR] = useState(
+    'lnbc120n1p39wfrtpp5n24pj26fpl0p9dsyxx47ttklcazd7z87pkmru4geca6n6kz4409qdpzve5kzar2v9nr5gpqw3hjqsrvde68scn0wssp5mqr9mkd94jm5z65x94msas8hqhcuc96tqtre3wqkrm305tcvzgmqxqy9gcqcqzys9qrsgqrzjqtx3k77yrrav9hye7zar2rtqlfkytl094dsp0ms5majzth6gt7ca6uhdkxl983uywgqqqqqqqqqq86qqjqrzjq0h9s36s2kpql0a99c6k4zfq7chcx9sjnsund8damcl96qvc4833tx69gvk26e6efsqqqqlgqqqqpjqqjqrzjqd98kxkpyw0l9tyy8r8q57k7zpy9zjmh6sez752wj6gcumqnj3yxzhdsmg6qq56utgqqqqqqqqqqqeqqjqxahrxthcc8syrjyklsg57mzsqauargyc748lf8s2dezw5x7aww0j5v4k5wz9p5x4ax840h4q0qmgucglkesgzvvc22wwmqc756ec02qp34yg8p'
+  )
+  const parsed = useComputedState(() => pr && decode(pr), [pr])
+  const [info, setInfo] = useState(null)
+
+  console.log(parsed)
+
+  return (
+    <>
+      <Textarea value={pr} onChange={ev => setPR(ev.target.value)} />
+      {parsed && (
+        <Row>
+          <PaymentRequest>
+            {parsed.sections.map(section => (
+              <Section
+                key={section.letters}
+                name={section.name}
+                onMouseEnter={() => setInfo(section)}
+                onMouseLeave={() => setInfo(null)}
+              >
+                {section.letters}
+              </Section>
+            ))}
+          </PaymentRequest>
+          {info && (
+            <Info name={info.name}>
+              <div>name: {info.name}</div>
+              {info.tag && <div>tag: {info.tag}</div>}
+              <div>value: {JSON.stringify(info.value)}</div>
+            </Info>
+          )}
+        </Row>
+      )}
+    </>
+  )
+}
+
+render(<Demo />, document.getElementById('main'))

node_modules/light-bolt11-decoder/examples/example.js

@@ -0,0 +1,5 @@
+let pr =
+  'lnbc20u1p3y0x3hpp5743k2g0fsqqxj7n8qzuhns5gmkk4djeejk3wkp64ppevgekvc0jsdqcve5kzar2v9nr5gpqd4hkuetesp5ez2g297jduwc20t6lmqlsg3man0vf2jfd8ar9fh8fhn2g8yttfkqxqy9gcqcqzys9qrsgqrzjqtx3k77yrrav9hye7zar2rtqlfkytl094dsp0ms5majzth6gt7ca6uhdkxl983uywgqqqqlgqqqvx5qqjqrzjqd98kxkpyw0l9tyy8r8q57k7zpy9zjmh6sez752wj6gcumqnj3yxzhdsmg6qq56utgqqqqqqqqqqqeqqjq7jd56882gtxhrjm03c93aacyfy306m4fq0tskf83c0nmet8zc2lxyyg3saz8x6vwcp26xnrlagf9semau3qm2glysp7sv95693fphvsp54l567'
+
+let d = require('..').decode(pr)
+console.log(d)

node_modules/light-bolt11-decoder/examples/index.html

@@ -0,0 +1,8 @@
+<!DOCTYPE html>
+
+<meta charset="utf-8" />
+<title>bolt11 demo</title>
+
+<div id="main" />
+
+<script src="demo.build.js"></script>

node_modules/light-bolt11-decoder/examples/node_modules/@babel/code-frame/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/light-bolt11-decoder/examples/node_modules/@babel/code-frame/README.md

@@ -0,0 +1,19 @@
+# @babel/code-frame
+
+> Generate errors that contain a code frame that point to source locations.
+
+See our website [@babel/code-frame](https://babeljs.io/docs/en/babel-code-frame) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/code-frame
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/code-frame --dev
+```

node_modules/light-bolt11-decoder/examples/node_modules/@babel/code-frame/lib/index.js

@@ -0,0 +1,163 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.codeFrameColumns = codeFrameColumns;
+exports.default = _default;
+
+var _highlight = require("@babel/highlight");
+
+let deprecationWarningShown = false;
+
+function getDefs(chalk) {
+  return {
+    gutter: chalk.grey,
+    marker: chalk.red.bold,
+    message: chalk.red.bold
+  };
+}
+
+const NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
+
+function getMarkerLines(loc, source, opts) {
+  const startLoc = Object.assign({
+    column: 0,
+    line: -1
+  }, loc.start);
+  const endLoc = Object.assign({}, startLoc, loc.end);
+  const {
+    linesAbove = 2,
+    linesBelow = 3
+  } = opts || {};
+  const startLine = startLoc.line;
+  const startColumn = startLoc.column;
+  const endLine = endLoc.line;
+  const endColumn = endLoc.column;
+  let start = Math.max(startLine - (linesAbove + 1), 0);
+  let end = Math.min(source.length, endLine + linesBelow);
+
+  if (startLine === -1) {
+    start = 0;
+  }
+
+  if (endLine === -1) {
+    end = source.length;
+  }
+
+  const lineDiff = endLine - startLine;
+  const markerLines = {};
+
+  if (lineDiff) {
+    for (let i = 0; i <= lineDiff; i++) {
+      const lineNumber = i + startLine;
+
+      if (!startColumn) {
+        markerLines[lineNumber] = true;
+      } else if (i === 0) {
+        const sourceLength = source[lineNumber - 1].length;
+        markerLines[lineNumber] = [startColumn, sourceLength - startColumn + 1];
+      } else if (i === lineDiff) {
+        markerLines[lineNumber] = [0, endColumn];
+      } else {
+        const sourceLength = source[lineNumber - i].length;
+        markerLines[lineNumber] = [0, sourceLength];
+      }
+    }
+  } else {
+    if (startColumn === endColumn) {
+      if (startColumn) {
+        markerLines[startLine] = [startColumn, 0];
+      } else {
+        markerLines[startLine] = true;
+      }
+    } else {
+      markerLines[startLine] = [startColumn, endColumn - startColumn];
+    }
+  }
+
+  return {
+    start,
+    end,
+    markerLines
+  };
+}
+
+function codeFrameColumns(rawLines, loc, opts = {}) {
+  const highlighted = (opts.highlightCode || opts.forceColor) && (0, _highlight.shouldHighlight)(opts);
+  const chalk = (0, _highlight.getChalk)(opts);
+  const defs = getDefs(chalk);
+
+  const maybeHighlight = (chalkFn, string) => {
+    return highlighted ? chalkFn(string) : string;
+  };
+
+  const lines = rawLines.split(NEWLINE);
+  const {
+    start,
+    end,
+    markerLines
+  } = getMarkerLines(loc, lines, opts);
+  const hasColumns = loc.start && typeof loc.start.column === "number";
+  const numberMaxWidth = String(end).length;
+  const highlightedLines = highlighted ? (0, _highlight.default)(rawLines, opts) : rawLines;
+  let frame = highlightedLines.split(NEWLINE, end).slice(start, end).map((line, index) => {
+    const number = start + 1 + index;
+    const paddedNumber = ` ${number}`.slice(-numberMaxWidth);
+    const gutter = ` ${paddedNumber} |`;
+    const hasMarker = markerLines[number];
+    const lastMarkerLine = !markerLines[number + 1];
+
+    if (hasMarker) {
+      let markerLine = "";
+
+      if (Array.isArray(hasMarker)) {
+        const markerSpacing = line.slice(0, Math.max(hasMarker[0] - 1, 0)).replace(/[^\t]/g, " ");
+        const numberOfMarkers = hasMarker[1] || 1;
+        markerLine = ["\n ", maybeHighlight(defs.gutter, gutter.replace(/\d/g, " ")), " ", markerSpacing, maybeHighlight(defs.marker, "^").repeat(numberOfMarkers)].join("");
+
+        if (lastMarkerLine && opts.message) {
+          markerLine += " " + maybeHighlight(defs.message, opts.message);
+        }
+      }
+
+      return [maybeHighlight(defs.marker, ">"), maybeHighlight(defs.gutter, gutter), line.length > 0 ? ` ${line}` : "", markerLine].join("");
+    } else {
+      return ` ${maybeHighlight(defs.gutter, gutter)}${line.length > 0 ? ` ${line}` : ""}`;
+    }
+  }).join("\n");
+
+  if (opts.message && !hasColumns) {
+    frame = `${" ".repeat(numberMaxWidth + 1)}${opts.message}\n${frame}`;
+  }
+
+  if (highlighted) {
+    return chalk.reset(frame);
+  } else {
+    return frame;
+  }
+}
+
+function _default(rawLines, lineNumber, colNumber, opts = {}) {
+  if (!deprecationWarningShown) {
+    deprecationWarningShown = true;
+    const message = "Passing lineNumber and colNumber is deprecated to @babel/code-frame. Please use `codeFrameColumns`.";
+
+    if (process.emitWarning) {
+      process.emitWarning(message, "DeprecationWarning");
+    } else {
+      const deprecationError = new Error(message);
+      deprecationError.name = "DeprecationWarning";
+      console.warn(new Error(message));
+    }
+  }
+
+  colNumber = Math.max(colNumber, 0);
+  const location = {
+    start: {
+      column: colNumber,
+      line: lineNumber
+    }
+  };
+  return codeFrameColumns(rawLines, location, opts);
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/code-frame/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@babel/code-frame",
+  "version": "7.16.7",
+  "description": "Generate errors that contain a code frame that point to source locations.",
+  "author": "The Babel Team (https://babel.dev/team)",
+  "homepage": "https://babel.dev/docs/en/next/babel-code-frame",
+  "bugs": "https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+is%3Aopen",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-code-frame"
+  },
+  "main": "./lib/index.js",
+  "dependencies": {
+    "@babel/highlight": "^7.16.7"
+  },
+  "devDependencies": {
+    "@types/chalk": "^2.0.0",
+    "chalk": "^2.0.0",
+    "strip-ansi": "^4.0.0"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  }
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/generator/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/light-bolt11-decoder/examples/node_modules/@babel/generator/README.md

@@ -0,0 +1,19 @@
+# @babel/generator
+
+> Turns an AST into code.
+
+See our website [@babel/generator](https://babeljs.io/docs/en/babel-generator) for more information or the [issues](https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20generator%22+is%3Aopen) associated with this package.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/generator
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/generator --dev
+```

node_modules/light-bolt11-decoder/examples/node_modules/@babel/generator/lib/buffer.js

@@ -0,0 +1,265 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+const SPACES_RE = /^[ \t]+$/;
+
+class Buffer {
+  constructor(map) {
+    this._map = null;
+    this._buf = "";
+    this._last = 0;
+    this._queue = [];
+    this._position = {
+      line: 1,
+      column: 0
+    };
+    this._sourcePosition = {
+      identifierName: null,
+      line: null,
+      column: null,
+      filename: null
+    };
+    this._disallowedPop = null;
+    this._map = map;
+  }
+
+  get() {
+    this._flush();
+
+    const map = this._map;
+    const result = {
+      code: this._buf.trimRight(),
+      map: null,
+      rawMappings: map == null ? void 0 : map.getRawMappings()
+    };
+
+    if (map) {
+      Object.defineProperty(result, "map", {
+        configurable: true,
+        enumerable: true,
+
+        get() {
+          return this.map = map.get();
+        },
+
+        set(value) {
+          Object.defineProperty(this, "map", {
+            value,
+            writable: true
+          });
+        }
+
+      });
+    }
+
+    return result;
+  }
+
+  append(str) {
+    this._flush();
+
+    const {
+      line,
+      column,
+      filename,
+      identifierName,
+      force
+    } = this._sourcePosition;
+
+    this._append(str, line, column, identifierName, filename, force);
+  }
+
+  queue(str) {
+    if (str === "\n") {
+      while (this._queue.length > 0 && SPACES_RE.test(this._queue[0][0])) {
+        this._queue.shift();
+      }
+    }
+
+    const {
+      line,
+      column,
+      filename,
+      identifierName,
+      force
+    } = this._sourcePosition;
+
+    this._queue.unshift([str, line, column, identifierName, filename, force]);
+  }
+
+  _flush() {
+    let item;
+
+    while (item = this._queue.pop()) {
+      this._append(...item);
+    }
+  }
+
+  _append(str, line, column, identifierName, filename, force) {
+    this._buf += str;
+    this._last = str.charCodeAt(str.length - 1);
+    let i = str.indexOf("\n");
+    let last = 0;
+
+    if (i !== 0) {
+      this._mark(line, column, identifierName, filename, force);
+    }
+
+    while (i !== -1) {
+      this._position.line++;
+      this._position.column = 0;
+      last = i + 1;
+
+      if (last < str.length) {
+        this._mark(++line, 0, identifierName, filename, force);
+      }
+
+      i = str.indexOf("\n", last);
+    }
+
+    this._position.column += str.length - last;
+  }
+
+  _mark(line, column, identifierName, filename, force) {
+    var _this$_map;
+
+    (_this$_map = this._map) == null ? void 0 : _this$_map.mark(this._position.line, this._position.column, line, column, identifierName, filename, force);
+  }
+
+  removeTrailingNewline() {
+    if (this._queue.length > 0 && this._queue[0][0] === "\n") {
+      this._queue.shift();
+    }
+  }
+
+  removeLastSemicolon() {
+    if (this._queue.length > 0 && this._queue[0][0] === ";") {
+      this._queue.shift();
+    }
+  }
+
+  getLastChar() {
+    let last;
+
+    if (this._queue.length > 0) {
+      const str = this._queue[0][0];
+      last = str.charCodeAt(0);
+    } else {
+      last = this._last;
+    }
+
+    return last;
+  }
+
+  endsWithCharAndNewline() {
+    const queue = this._queue;
+
+    if (queue.length > 0) {
+      const last = queue[0][0];
+      const lastCp = last.charCodeAt(0);
+      if (lastCp !== 10) return;
+
+      if (queue.length > 1) {
+        const secondLast = queue[1][0];
+        return secondLast.charCodeAt(0);
+      } else {
+        return this._last;
+      }
+    }
+  }
+
+  hasContent() {
+    return this._queue.length > 0 || !!this._last;
+  }
+
+  exactSource(loc, cb) {
+    this.source("start", loc, true);
+    cb();
+    this.source("end", loc);
+
+    this._disallowPop("start", loc);
+  }
+
+  source(prop, loc, force) {
+    if (prop && !loc) return;
+
+    this._normalizePosition(prop, loc, this._sourcePosition, force);
+  }
+
+  withSource(prop, loc, cb) {
+    if (!this._map) return cb();
+    const originalLine = this._sourcePosition.line;
+    const originalColumn = this._sourcePosition.column;
+    const originalFilename = this._sourcePosition.filename;
+    const originalIdentifierName = this._sourcePosition.identifierName;
+    this.source(prop, loc);
+    cb();
+
+    if ((!this._sourcePosition.force || this._sourcePosition.line !== originalLine || this._sourcePosition.column !== originalColumn || this._sourcePosition.filename !== originalFilename) && (!this._disallowedPop || this._disallowedPop.line !== originalLine || this._disallowedPop.column !== originalColumn || this._disallowedPop.filename !== originalFilename)) {
+      this._sourcePosition.line = originalLine;
+      this._sourcePosition.column = originalColumn;
+      this._sourcePosition.filename = originalFilename;
+      this._sourcePosition.identifierName = originalIdentifierName;
+      this._sourcePosition.force = false;
+      this._disallowedPop = null;
+    }
+  }
+
+  _disallowPop(prop, loc) {
+    if (prop && !loc) return;
+    this._disallowedPop = this._normalizePosition(prop, loc);
+  }
+
+  _normalizePosition(prop, loc, targetObj, force) {
+    const pos = loc ? loc[prop] : null;
+
+    if (targetObj === undefined) {
+      targetObj = {
+        identifierName: null,
+        line: null,
+        column: null,
+        filename: null,
+        force: false
+      };
+    }
+
+    const origLine = targetObj.line;
+    const origColumn = targetObj.column;
+    const origFilename = targetObj.filename;
+    targetObj.identifierName = prop === "start" && (loc == null ? void 0 : loc.identifierName) || null;
+    targetObj.line = pos == null ? void 0 : pos.line;
+    targetObj.column = pos == null ? void 0 : pos.column;
+    targetObj.filename = loc == null ? void 0 : loc.filename;
+
+    if (force || targetObj.line !== origLine || targetObj.column !== origColumn || targetObj.filename !== origFilename) {
+      targetObj.force = force;
+    }
+
+    return targetObj;
+  }
+
+  getCurrentColumn() {
+    const extra = this._queue.reduce((acc, item) => item[0] + acc, "");
+
+    const lastIndex = extra.lastIndexOf("\n");
+    return lastIndex === -1 ? this._position.column + extra.length : extra.length - 1 - lastIndex;
+  }
+
+  getCurrentLine() {
+    const extra = this._queue.reduce((acc, item) => item[0] + acc, "");
+
+    let count = 0;
+
+    for (let i = 0; i < extra.length; i++) {
+      if (extra[i] === "\n") count++;
+    }
+
+    return this._position.line + count;
+  }
+
+}
+
+exports.default = Buffer;

node_modules/light-bolt11-decoder/examples/node_modules/@babel/generator/lib/generators/base.js

@@ -0,0 +1,96 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BlockStatement = BlockStatement;
+exports.Directive = Directive;
+exports.DirectiveLiteral = DirectiveLiteral;
+exports.File = File;
+exports.InterpreterDirective = InterpreterDirective;
+exports.Placeholder = Placeholder;
+exports.Program = Program;
+
+function File(node) {
+  if (node.program) {
+    this.print(node.program.interpreter, node);
+  }
+
+  this.print(node.program, node);
+}
+
+function Program(node) {
+  this.printInnerComments(node, false);
+  this.printSequence(node.directives, node);
+  if (node.directives && node.directives.length) this.newline();
+  this.printSequence(node.body, node);
+}
+
+function BlockStatement(node) {
+  var _node$directives;
+
+  this.token("{");
+  this.printInnerComments(node);
+  const hasDirectives = (_node$directives = node.directives) == null ? void 0 : _node$directives.length;
+
+  if (node.body.length || hasDirectives) {
+    this.newline();
+    this.printSequence(node.directives, node, {
+      indent: true
+    });
+    if (hasDirectives) this.newline();
+    this.printSequence(node.body, node, {
+      indent: true
+    });
+    this.removeTrailingNewline();
+    this.source("end", node.loc);
+    if (!this.endsWith(10)) this.newline();
+    this.rightBrace();
+  } else {
+    this.source("end", node.loc);
+    this.token("}");
+  }
+}
+
+function Directive(node) {
+  this.print(node.value, node);
+  this.semicolon();
+}
+
+const unescapedSingleQuoteRE = /(?:^|[^\\])(?:\\\\)*'/;
+const unescapedDoubleQuoteRE = /(?:^|[^\\])(?:\\\\)*"/;
+
+function DirectiveLiteral(node) {
+  const raw = this.getPossibleRaw(node);
+
+  if (!this.format.minified && raw != null) {
+    this.token(raw);
+    return;
+  }
+
+  const {
+    value
+  } = node;
+
+  if (!unescapedDoubleQuoteRE.test(value)) {
+    this.token(`"${value}"`);
+  } else if (!unescapedSingleQuoteRE.test(value)) {
+    this.token(`'${value}'`);
+  } else {
+    throw new Error("Malformed AST: it is not possible to print a directive containing" + " both unescaped single and double quotes.");
+  }
+}
+
+function InterpreterDirective(node) {
+  this.token(`#!${node.value}\n`);
+}
+
+function Placeholder(node) {
+  this.token("%%");
+  this.print(node.name);
+  this.token("%%");
+
+  if (node.expectedNode === "Statement") {
+    this.semicolon();
+  }
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/generator/lib/generators/classes.js

@@ -0,0 +1,213 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ClassAccessorProperty = ClassAccessorProperty;
+exports.ClassBody = ClassBody;
+exports.ClassExpression = exports.ClassDeclaration = ClassDeclaration;
+exports.ClassMethod = ClassMethod;
+exports.ClassPrivateMethod = ClassPrivateMethod;
+exports.ClassPrivateProperty = ClassPrivateProperty;
+exports.ClassProperty = ClassProperty;
+exports.StaticBlock = StaticBlock;
+exports._classMethodHead = _classMethodHead;
+
+var _t = require("@babel/types");
+
+const {
+  isExportDefaultDeclaration,
+  isExportNamedDeclaration
+} = _t;
+
+function ClassDeclaration(node, parent) {
+  if (!this.format.decoratorsBeforeExport || !isExportDefaultDeclaration(parent) && !isExportNamedDeclaration(parent)) {
+    this.printJoin(node.decorators, node);
+  }
+
+  if (node.declare) {
+    this.word("declare");
+    this.space();
+  }
+
+  if (node.abstract) {
+    this.word("abstract");
+    this.space();
+  }
+
+  this.word("class");
+  this.printInnerComments(node);
+
+  if (node.id) {
+    this.space();
+    this.print(node.id, node);
+  }
+
+  this.print(node.typeParameters, node);
+
+  if (node.superClass) {
+    this.space();
+    this.word("extends");
+    this.space();
+    this.print(node.superClass, node);
+    this.print(node.superTypeParameters, node);
+  }
+
+  if (node.implements) {
+    this.space();
+    this.word("implements");
+    this.space();
+    this.printList(node.implements, node);
+  }
+
+  this.space();
+  this.print(node.body, node);
+}
+
+function ClassBody(node) {
+  this.token("{");
+  this.printInnerComments(node);
+
+  if (node.body.length === 0) {
+    this.token("}");
+  } else {
+    this.newline();
+    this.indent();
+    this.printSequence(node.body, node);
+    this.dedent();
+    if (!this.endsWith(10)) this.newline();
+    this.rightBrace();
+  }
+}
+
+function ClassProperty(node) {
+  this.printJoin(node.decorators, node);
+  this.source("end", node.key.loc);
+  this.tsPrintClassMemberModifiers(node, true);
+
+  if (node.computed) {
+    this.token("[");
+    this.print(node.key, node);
+    this.token("]");
+  } else {
+    this._variance(node);
+
+    this.print(node.key, node);
+  }
+
+  if (node.optional) {
+    this.token("?");
+  }
+
+  if (node.definite) {
+    this.token("!");
+  }
+
+  this.print(node.typeAnnotation, node);
+
+  if (node.value) {
+    this.space();
+    this.token("=");
+    this.space();
+    this.print(node.value, node);
+  }
+
+  this.semicolon();
+}
+
+function ClassAccessorProperty(node) {
+  this.printJoin(node.decorators, node);
+  this.source("end", node.key.loc);
+  this.tsPrintClassMemberModifiers(node, true);
+  this.word("accessor");
+  this.printInnerComments(node);
+  this.space();
+
+  if (node.computed) {
+    this.token("[");
+    this.print(node.key, node);
+    this.token("]");
+  } else {
+    this._variance(node);
+
+    this.print(node.key, node);
+  }
+
+  if (node.optional) {
+    this.token("?");
+  }
+
+  if (node.definite) {
+    this.token("!");
+  }
+
+  this.print(node.typeAnnotation, node);
+
+  if (node.value) {
+    this.space();
+    this.token("=");
+    this.space();
+    this.print(node.value, node);
+  }
+
+  this.semicolon();
+}
+
+function ClassPrivateProperty(node) {
+  this.printJoin(node.decorators, node);
+
+  if (node.static) {
+    this.word("static");
+    this.space();
+  }
+
+  this.print(node.key, node);
+  this.print(node.typeAnnotation, node);
+
+  if (node.value) {
+    this.space();
+    this.token("=");
+    this.space();
+    this.print(node.value, node);
+  }
+
+  this.semicolon();
+}
+
+function ClassMethod(node) {
+  this._classMethodHead(node);
+
+  this.space();
+  this.print(node.body, node);
+}
+
+function ClassPrivateMethod(node) {
+  this._classMethodHead(node);
+
+  this.space();
+  this.print(node.body, node);
+}
+
+function _classMethodHead(node) {
+  this.printJoin(node.decorators, node);
+  this.source("end", node.key.loc);
+  this.tsPrintClassMemberModifiers(node, false);
+
+  this._methodHead(node);
+}
+
+function StaticBlock(node) {
+  this.word("static");
+  this.space();
+  this.token("{");
+
+  if (node.body.length === 0) {
+    this.token("}");
+  } else {
+    this.newline();
+    this.printSequence(node.body, node, {
+      indent: true
+    });
+    this.rightBrace();
+  }
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/generator/lib/generators/expressions.js

@@ -0,0 +1,354 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LogicalExpression = exports.BinaryExpression = exports.AssignmentExpression = AssignmentExpression;
+exports.AssignmentPattern = AssignmentPattern;
+exports.AwaitExpression = void 0;
+exports.BindExpression = BindExpression;
+exports.CallExpression = CallExpression;
+exports.ConditionalExpression = ConditionalExpression;
+exports.Decorator = Decorator;
+exports.DoExpression = DoExpression;
+exports.EmptyStatement = EmptyStatement;
+exports.ExpressionStatement = ExpressionStatement;
+exports.Import = Import;
+exports.MemberExpression = MemberExpression;
+exports.MetaProperty = MetaProperty;
+exports.ModuleExpression = ModuleExpression;
+exports.NewExpression = NewExpression;
+exports.OptionalCallExpression = OptionalCallExpression;
+exports.OptionalMemberExpression = OptionalMemberExpression;
+exports.ParenthesizedExpression = ParenthesizedExpression;
+exports.PrivateName = PrivateName;
+exports.SequenceExpression = SequenceExpression;
+exports.Super = Super;
+exports.ThisExpression = ThisExpression;
+exports.UnaryExpression = UnaryExpression;
+exports.UpdateExpression = UpdateExpression;
+exports.V8IntrinsicIdentifier = V8IntrinsicIdentifier;
+exports.YieldExpression = void 0;
+
+var _t = require("@babel/types");
+
+var n = require("../node");
+
+const {
+  isCallExpression,
+  isLiteral,
+  isMemberExpression,
+  isNewExpression
+} = _t;
+
+function UnaryExpression(node) {
+  if (node.operator === "void" || node.operator === "delete" || node.operator === "typeof" || node.operator === "throw") {
+    this.word(node.operator);
+    this.space();
+  } else {
+    this.token(node.operator);
+  }
+
+  this.print(node.argument, node);
+}
+
+function DoExpression(node) {
+  if (node.async) {
+    this.word("async");
+    this.space();
+  }
+
+  this.word("do");
+  this.space();
+  this.print(node.body, node);
+}
+
+function ParenthesizedExpression(node) {
+  this.token("(");
+  this.print(node.expression, node);
+  this.token(")");
+}
+
+function UpdateExpression(node) {
+  if (node.prefix) {
+    this.token(node.operator);
+    this.print(node.argument, node);
+  } else {
+    this.startTerminatorless(true);
+    this.print(node.argument, node);
+    this.endTerminatorless();
+    this.token(node.operator);
+  }
+}
+
+function ConditionalExpression(node) {
+  this.print(node.test, node);
+  this.space();
+  this.token("?");
+  this.space();
+  this.print(node.consequent, node);
+  this.space();
+  this.token(":");
+  this.space();
+  this.print(node.alternate, node);
+}
+
+function NewExpression(node, parent) {
+  this.word("new");
+  this.space();
+  this.print(node.callee, node);
+
+  if (this.format.minified && node.arguments.length === 0 && !node.optional && !isCallExpression(parent, {
+    callee: node
+  }) && !isMemberExpression(parent) && !isNewExpression(parent)) {
+    return;
+  }
+
+  this.print(node.typeArguments, node);
+  this.print(node.typeParameters, node);
+
+  if (node.optional) {
+    this.token("?.");
+  }
+
+  this.token("(");
+  this.printList(node.arguments, node);
+  this.token(")");
+}
+
+function SequenceExpression(node) {
+  this.printList(node.expressions, node);
+}
+
+function ThisExpression() {
+  this.word("this");
+}
+
+function Super() {
+  this.word("super");
+}
+
+function isDecoratorMemberExpression(node) {
+  switch (node.type) {
+    case "Identifier":
+      return true;
+
+    case "MemberExpression":
+      return !node.computed && node.property.type === "Identifier" && isDecoratorMemberExpression(node.object);
+
+    default:
+      return false;
+  }
+}
+
+function shouldParenthesizeDecoratorExpression(node) {
+  if (node.type === "CallExpression") {
+    node = node.callee;
+  }
+
+  if (node.type === "ParenthesizedExpression") {
+    return false;
+  }
+
+  return !isDecoratorMemberExpression(node);
+}
+
+function Decorator(node) {
+  this.token("@");
+  const {
+    expression
+  } = node;
+
+  if (shouldParenthesizeDecoratorExpression(expression)) {
+    this.token("(");
+    this.print(expression, node);
+    this.token(")");
+  } else {
+    this.print(expression, node);
+  }
+
+  this.newline();
+}
+
+function OptionalMemberExpression(node) {
+  this.print(node.object, node);
+
+  if (!node.computed && isMemberExpression(node.property)) {
+    throw new TypeError("Got a MemberExpression for MemberExpression property");
+  }
+
+  let computed = node.computed;
+
+  if (isLiteral(node.property) && typeof node.property.value === "number") {
+    computed = true;
+  }
+
+  if (node.optional) {
+    this.token("?.");
+  }
+
+  if (computed) {
+    this.token("[");
+    this.print(node.property, node);
+    this.token("]");
+  } else {
+    if (!node.optional) {
+      this.token(".");
+    }
+
+    this.print(node.property, node);
+  }
+}
+
+function OptionalCallExpression(node) {
+  this.print(node.callee, node);
+  this.print(node.typeArguments, node);
+  this.print(node.typeParameters, node);
+
+  if (node.optional) {
+    this.token("?.");
+  }
+
+  this.token("(");
+  this.printList(node.arguments, node);
+  this.token(")");
+}
+
+function CallExpression(node) {
+  this.print(node.callee, node);
+  this.print(node.typeArguments, node);
+  this.print(node.typeParameters, node);
+  this.token("(");
+  this.printList(node.arguments, node);
+  this.token(")");
+}
+
+function Import() {
+  this.word("import");
+}
+
+function buildYieldAwait(keyword) {
+  return function (node) {
+    this.word(keyword);
+
+    if (node.delegate) {
+      this.token("*");
+    }
+
+    if (node.argument) {
+      this.space();
+      const terminatorState = this.startTerminatorless();
+      this.print(node.argument, node);
+      this.endTerminatorless(terminatorState);
+    }
+  };
+}
+
+const YieldExpression = buildYieldAwait("yield");
+exports.YieldExpression = YieldExpression;
+const AwaitExpression = buildYieldAwait("await");
+exports.AwaitExpression = AwaitExpression;
+
+function EmptyStatement() {
+  this.semicolon(true);
+}
+
+function ExpressionStatement(node) {
+  this.print(node.expression, node);
+  this.semicolon();
+}
+
+function AssignmentPattern(node) {
+  this.print(node.left, node);
+  if (node.left.optional) this.token("?");
+  this.print(node.left.typeAnnotation, node);
+  this.space();
+  this.token("=");
+  this.space();
+  this.print(node.right, node);
+}
+
+function AssignmentExpression(node, parent) {
+  const parens = this.inForStatementInitCounter && node.operator === "in" && !n.needsParens(node, parent);
+
+  if (parens) {
+    this.token("(");
+  }
+
+  this.print(node.left, node);
+  this.space();
+
+  if (node.operator === "in" || node.operator === "instanceof") {
+    this.word(node.operator);
+  } else {
+    this.token(node.operator);
+  }
+
+  this.space();
+  this.print(node.right, node);
+
+  if (parens) {
+    this.token(")");
+  }
+}
+
+function BindExpression(node) {
+  this.print(node.object, node);
+  this.token("::");
+  this.print(node.callee, node);
+}
+
+function MemberExpression(node) {
+  this.print(node.object, node);
+
+  if (!node.computed && isMemberExpression(node.property)) {
+    throw new TypeError("Got a MemberExpression for MemberExpression property");
+  }
+
+  let computed = node.computed;
+
+  if (isLiteral(node.property) && typeof node.property.value === "number") {
+    computed = true;
+  }
+
+  if (computed) {
+    this.token("[");
+    this.print(node.property, node);
+    this.token("]");
+  } else {
+    this.token(".");
+    this.print(node.property, node);
+  }
+}
+
+function MetaProperty(node) {
+  this.print(node.meta, node);
+  this.token(".");
+  this.print(node.property, node);
+}
+
+function PrivateName(node) {
+  this.token("#");
+  this.print(node.id, node);
+}
+
+function V8IntrinsicIdentifier(node) {
+  this.token("%");
+  this.word(node.name);
+}
+
+function ModuleExpression(node) {
+  this.word("module");
+  this.space();
+  this.token("{");
+
+  if (node.body.body.length === 0) {
+    this.token("}");
+  } else {
+    this.newline();
+    this.printSequence(node.body.body, node, {
+      indent: true
+    });
+    this.rightBrace();
+  }
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/generator/lib/generators/flow.js

@@ -0,0 +1,795 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AnyTypeAnnotation = AnyTypeAnnotation;
+exports.ArrayTypeAnnotation = ArrayTypeAnnotation;
+exports.BooleanLiteralTypeAnnotation = BooleanLiteralTypeAnnotation;
+exports.BooleanTypeAnnotation = BooleanTypeAnnotation;
+exports.DeclareClass = DeclareClass;
+exports.DeclareExportAllDeclaration = DeclareExportAllDeclaration;
+exports.DeclareExportDeclaration = DeclareExportDeclaration;
+exports.DeclareFunction = DeclareFunction;
+exports.DeclareInterface = DeclareInterface;
+exports.DeclareModule = DeclareModule;
+exports.DeclareModuleExports = DeclareModuleExports;
+exports.DeclareOpaqueType = DeclareOpaqueType;
+exports.DeclareTypeAlias = DeclareTypeAlias;
+exports.DeclareVariable = DeclareVariable;
+exports.DeclaredPredicate = DeclaredPredicate;
+exports.EmptyTypeAnnotation = EmptyTypeAnnotation;
+exports.EnumBooleanBody = EnumBooleanBody;
+exports.EnumBooleanMember = EnumBooleanMember;
+exports.EnumDeclaration = EnumDeclaration;
+exports.EnumDefaultedMember = EnumDefaultedMember;
+exports.EnumNumberBody = EnumNumberBody;
+exports.EnumNumberMember = EnumNumberMember;
+exports.EnumStringBody = EnumStringBody;
+exports.EnumStringMember = EnumStringMember;
+exports.EnumSymbolBody = EnumSymbolBody;
+exports.ExistsTypeAnnotation = ExistsTypeAnnotation;
+exports.FunctionTypeAnnotation = FunctionTypeAnnotation;
+exports.FunctionTypeParam = FunctionTypeParam;
+exports.IndexedAccessType = IndexedAccessType;
+exports.InferredPredicate = InferredPredicate;
+exports.InterfaceDeclaration = InterfaceDeclaration;
+exports.GenericTypeAnnotation = exports.ClassImplements = exports.InterfaceExtends = InterfaceExtends;
+exports.InterfaceTypeAnnotation = InterfaceTypeAnnotation;
+exports.IntersectionTypeAnnotation = IntersectionTypeAnnotation;
+exports.MixedTypeAnnotation = MixedTypeAnnotation;
+exports.NullLiteralTypeAnnotation = NullLiteralTypeAnnotation;
+exports.NullableTypeAnnotation = NullableTypeAnnotation;
+Object.defineProperty(exports, "NumberLiteralTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _types2.NumericLiteral;
+  }
+});
+exports.NumberTypeAnnotation = NumberTypeAnnotation;
+exports.ObjectTypeAnnotation = ObjectTypeAnnotation;
+exports.ObjectTypeCallProperty = ObjectTypeCallProperty;
+exports.ObjectTypeIndexer = ObjectTypeIndexer;
+exports.ObjectTypeInternalSlot = ObjectTypeInternalSlot;
+exports.ObjectTypeProperty = ObjectTypeProperty;
+exports.ObjectTypeSpreadProperty = ObjectTypeSpreadProperty;
+exports.OpaqueType = OpaqueType;
+exports.OptionalIndexedAccessType = OptionalIndexedAccessType;
+exports.QualifiedTypeIdentifier = QualifiedTypeIdentifier;
+Object.defineProperty(exports, "StringLiteralTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _types2.StringLiteral;
+  }
+});
+exports.StringTypeAnnotation = StringTypeAnnotation;
+exports.SymbolTypeAnnotation = SymbolTypeAnnotation;
+exports.ThisTypeAnnotation = ThisTypeAnnotation;
+exports.TupleTypeAnnotation = TupleTypeAnnotation;
+exports.TypeAlias = TypeAlias;
+exports.TypeAnnotation = TypeAnnotation;
+exports.TypeCastExpression = TypeCastExpression;
+exports.TypeParameter = TypeParameter;
+exports.TypeParameterDeclaration = exports.TypeParameterInstantiation = TypeParameterInstantiation;
+exports.TypeofTypeAnnotation = TypeofTypeAnnotation;
+exports.UnionTypeAnnotation = UnionTypeAnnotation;
+exports.Variance = Variance;
+exports.VoidTypeAnnotation = VoidTypeAnnotation;
+exports._interfaceish = _interfaceish;
+exports._variance = _variance;
+
+var _t = require("@babel/types");
+
+var _modules = require("./modules");
+
+var _types2 = require("./types");
+
+const {
+  isDeclareExportDeclaration,
+  isStatement
+} = _t;
+
+function AnyTypeAnnotation() {
+  this.word("any");
+}
+
+function ArrayTypeAnnotation(node) {
+  this.print(node.elementType, node);
+  this.token("[");
+  this.token("]");
+}
+
+function BooleanTypeAnnotation() {
+  this.word("boolean");
+}
+
+function BooleanLiteralTypeAnnotation(node) {
+  this.word(node.value ? "true" : "false");
+}
+
+function NullLiteralTypeAnnotation() {
+  this.word("null");
+}
+
+function DeclareClass(node, parent) {
+  if (!isDeclareExportDeclaration(parent)) {
+    this.word("declare");
+    this.space();
+  }
+
+  this.word("class");
+  this.space();
+
+  this._interfaceish(node);
+}
+
+function DeclareFunction(node, parent) {
+  if (!isDeclareExportDeclaration(parent)) {
+    this.word("declare");
+    this.space();
+  }
+
+  this.word("function");
+  this.space();
+  this.print(node.id, node);
+  this.print(node.id.typeAnnotation.typeAnnotation, node);
+
+  if (node.predicate) {
+    this.space();
+    this.print(node.predicate, node);
+  }
+
+  this.semicolon();
+}
+
+function InferredPredicate() {
+  this.token("%");
+  this.word("checks");
+}
+
+function DeclaredPredicate(node) {
+  this.token("%");
+  this.word("checks");
+  this.token("(");
+  this.print(node.value, node);
+  this.token(")");
+}
+
+function DeclareInterface(node) {
+  this.word("declare");
+  this.space();
+  this.InterfaceDeclaration(node);
+}
+
+function DeclareModule(node) {
+  this.word("declare");
+  this.space();
+  this.word("module");
+  this.space();
+  this.print(node.id, node);
+  this.space();
+  this.print(node.body, node);
+}
+
+function DeclareModuleExports(node) {
+  this.word("declare");
+  this.space();
+  this.word("module");
+  this.token(".");
+  this.word("exports");
+  this.print(node.typeAnnotation, node);
+}
+
+function DeclareTypeAlias(node) {
+  this.word("declare");
+  this.space();
+  this.TypeAlias(node);
+}
+
+function DeclareOpaqueType(node, parent) {
+  if (!isDeclareExportDeclaration(parent)) {
+    this.word("declare");
+    this.space();
+  }
+
+  this.OpaqueType(node);
+}
+
+function DeclareVariable(node, parent) {
+  if (!isDeclareExportDeclaration(parent)) {
+    this.word("declare");
+    this.space();
+  }
+
+  this.word("var");
+  this.space();
+  this.print(node.id, node);
+  this.print(node.id.typeAnnotation, node);
+  this.semicolon();
+}
+
+function DeclareExportDeclaration(node) {
+  this.word("declare");
+  this.space();
+  this.word("export");
+  this.space();
+
+  if (node.default) {
+    this.word("default");
+    this.space();
+  }
+
+  FlowExportDeclaration.apply(this, arguments);
+}
+
+function DeclareExportAllDeclaration() {
+  this.word("declare");
+  this.space();
+
+  _modules.ExportAllDeclaration.apply(this, arguments);
+}
+
+function EnumDeclaration(node) {
+  const {
+    id,
+    body
+  } = node;
+  this.word("enum");
+  this.space();
+  this.print(id, node);
+  this.print(body, node);
+}
+
+function enumExplicitType(context, name, hasExplicitType) {
+  if (hasExplicitType) {
+    context.space();
+    context.word("of");
+    context.space();
+    context.word(name);
+  }
+
+  context.space();
+}
+
+function enumBody(context, node) {
+  const {
+    members
+  } = node;
+  context.token("{");
+  context.indent();
+  context.newline();
+
+  for (const member of members) {
+    context.print(member, node);
+    context.newline();
+  }
+
+  if (node.hasUnknownMembers) {
+    context.token("...");
+    context.newline();
+  }
+
+  context.dedent();
+  context.token("}");
+}
+
+function EnumBooleanBody(node) {
+  const {
+    explicitType
+  } = node;
+  enumExplicitType(this, "boolean", explicitType);
+  enumBody(this, node);
+}
+
+function EnumNumberBody(node) {
+  const {
+    explicitType
+  } = node;
+  enumExplicitType(this, "number", explicitType);
+  enumBody(this, node);
+}
+
+function EnumStringBody(node) {
+  const {
+    explicitType
+  } = node;
+  enumExplicitType(this, "string", explicitType);
+  enumBody(this, node);
+}
+
+function EnumSymbolBody(node) {
+  enumExplicitType(this, "symbol", true);
+  enumBody(this, node);
+}
+
+function EnumDefaultedMember(node) {
+  const {
+    id
+  } = node;
+  this.print(id, node);
+  this.token(",");
+}
+
+function enumInitializedMember(context, node) {
+  const {
+    id,
+    init
+  } = node;
+  context.print(id, node);
+  context.space();
+  context.token("=");
+  context.space();
+  context.print(init, node);
+  context.token(",");
+}
+
+function EnumBooleanMember(node) {
+  enumInitializedMember(this, node);
+}
+
+function EnumNumberMember(node) {
+  enumInitializedMember(this, node);
+}
+
+function EnumStringMember(node) {
+  enumInitializedMember(this, node);
+}
+
+function FlowExportDeclaration(node) {
+  if (node.declaration) {
+    const declar = node.declaration;
+    this.print(declar, node);
+    if (!isStatement(declar)) this.semicolon();
+  } else {
+    this.token("{");
+
+    if (node.specifiers.length) {
+      this.space();
+      this.printList(node.specifiers, node);
+      this.space();
+    }
+
+    this.token("}");
+
+    if (node.source) {
+      this.space();
+      this.word("from");
+      this.space();
+      this.print(node.source, node);
+    }
+
+    this.semicolon();
+  }
+}
+
+function ExistsTypeAnnotation() {
+  this.token("*");
+}
+
+function FunctionTypeAnnotation(node, parent) {
+  this.print(node.typeParameters, node);
+  this.token("(");
+
+  if (node.this) {
+    this.word("this");
+    this.token(":");
+    this.space();
+    this.print(node.this.typeAnnotation, node);
+
+    if (node.params.length || node.rest) {
+      this.token(",");
+      this.space();
+    }
+  }
+
+  this.printList(node.params, node);
+
+  if (node.rest) {
+    if (node.params.length) {
+      this.token(",");
+      this.space();
+    }
+
+    this.token("...");
+    this.print(node.rest, node);
+  }
+
+  this.token(")");
+
+  if (parent && (parent.type === "ObjectTypeCallProperty" || parent.type === "DeclareFunction" || parent.type === "ObjectTypeProperty" && parent.method)) {
+    this.token(":");
+  } else {
+    this.space();
+    this.token("=>");
+  }
+
+  this.space();
+  this.print(node.returnType, node);
+}
+
+function FunctionTypeParam(node) {
+  this.print(node.name, node);
+  if (node.optional) this.token("?");
+
+  if (node.name) {
+    this.token(":");
+    this.space();
+  }
+
+  this.print(node.typeAnnotation, node);
+}
+
+function InterfaceExtends(node) {
+  this.print(node.id, node);
+  this.print(node.typeParameters, node);
+}
+
+function _interfaceish(node) {
+  var _node$extends;
+
+  this.print(node.id, node);
+  this.print(node.typeParameters, node);
+
+  if ((_node$extends = node.extends) != null && _node$extends.length) {
+    this.space();
+    this.word("extends");
+    this.space();
+    this.printList(node.extends, node);
+  }
+
+  if (node.mixins && node.mixins.length) {
+    this.space();
+    this.word("mixins");
+    this.space();
+    this.printList(node.mixins, node);
+  }
+
+  if (node.implements && node.implements.length) {
+    this.space();
+    this.word("implements");
+    this.space();
+    this.printList(node.implements, node);
+  }
+
+  this.space();
+  this.print(node.body, node);
+}
+
+function _variance(node) {
+  if (node.variance) {
+    if (node.variance.kind === "plus") {
+      this.token("+");
+    } else if (node.variance.kind === "minus") {
+      this.token("-");
+    }
+  }
+}
+
+function InterfaceDeclaration(node) {
+  this.word("interface");
+  this.space();
+
+  this._interfaceish(node);
+}
+
+function andSeparator() {
+  this.space();
+  this.token("&");
+  this.space();
+}
+
+function InterfaceTypeAnnotation(node) {
+  this.word("interface");
+
+  if (node.extends && node.extends.length) {
+    this.space();
+    this.word("extends");
+    this.space();
+    this.printList(node.extends, node);
+  }
+
+  this.space();
+  this.print(node.body, node);
+}
+
+function IntersectionTypeAnnotation(node) {
+  this.printJoin(node.types, node, {
+    separator: andSeparator
+  });
+}
+
+function MixedTypeAnnotation() {
+  this.word("mixed");
+}
+
+function EmptyTypeAnnotation() {
+  this.word("empty");
+}
+
+function NullableTypeAnnotation(node) {
+  this.token("?");
+  this.print(node.typeAnnotation, node);
+}
+
+function NumberTypeAnnotation() {
+  this.word("number");
+}
+
+function StringTypeAnnotation() {
+  this.word("string");
+}
+
+function ThisTypeAnnotation() {
+  this.word("this");
+}
+
+function TupleTypeAnnotation(node) {
+  this.token("[");
+  this.printList(node.types, node);
+  this.token("]");
+}
+
+function TypeofTypeAnnotation(node) {
+  this.word("typeof");
+  this.space();
+  this.print(node.argument, node);
+}
+
+function TypeAlias(node) {
+  this.word("type");
+  this.space();
+  this.print(node.id, node);
+  this.print(node.typeParameters, node);
+  this.space();
+  this.token("=");
+  this.space();
+  this.print(node.right, node);
+  this.semicolon();
+}
+
+function TypeAnnotation(node) {
+  this.token(":");
+  this.space();
+  if (node.optional) this.token("?");
+  this.print(node.typeAnnotation, node);
+}
+
+function TypeParameterInstantiation(node) {
+  this.token("<");
+  this.printList(node.params, node, {});
+  this.token(">");
+}
+
+function TypeParameter(node) {
+  this._variance(node);
+
+  this.word(node.name);
+
+  if (node.bound) {
+    this.print(node.bound, node);
+  }
+
+  if (node.default) {
+    this.space();
+    this.token("=");
+    this.space();
+    this.print(node.default, node);
+  }
+}
+
+function OpaqueType(node) {
+  this.word("opaque");
+  this.space();
+  this.word("type");
+  this.space();
+  this.print(node.id, node);
+  this.print(node.typeParameters, node);
+
+  if (node.supertype) {
+    this.token(":");
+    this.space();
+    this.print(node.supertype, node);
+  }
+
+  if (node.impltype) {
+    this.space();
+    this.token("=");
+    this.space();
+    this.print(node.impltype, node);
+  }
+
+  this.semicolon();
+}
+
+function ObjectTypeAnnotation(node) {
+  if (node.exact) {
+    this.token("{|");
+  } else {
+    this.token("{");
+  }
+
+  const props = [...node.properties, ...(node.callProperties || []), ...(node.indexers || []), ...(node.internalSlots || [])];
+
+  if (props.length) {
+    this.space();
+    this.printJoin(props, node, {
+      addNewlines(leading) {
+        if (leading && !props[0]) return 1;
+      },
+
+      indent: true,
+      statement: true,
+      iterator: () => {
+        if (props.length !== 1 || node.inexact) {
+          this.token(",");
+          this.space();
+        }
+      }
+    });
+    this.space();
+  }
+
+  if (node.inexact) {
+    this.indent();
+    this.token("...");
+
+    if (props.length) {
+      this.newline();
+    }
+
+    this.dedent();
+  }
+
+  if (node.exact) {
+    this.token("|}");
+  } else {
+    this.token("}");
+  }
+}
+
+function ObjectTypeInternalSlot(node) {
+  if (node.static) {
+    this.word("static");
+    this.space();
+  }
+
+  this.token("[");
+  this.token("[");
+  this.print(node.id, node);
+  this.token("]");
+  this.token("]");
+  if (node.optional) this.token("?");
+
+  if (!node.method) {
+    this.token(":");
+    this.space();
+  }
+
+  this.print(node.value, node);
+}
+
+function ObjectTypeCallProperty(node) {
+  if (node.static) {
+    this.word("static");
+    this.space();
+  }
+
+  this.print(node.value, node);
+}
+
+function ObjectTypeIndexer(node) {
+  if (node.static) {
+    this.word("static");
+    this.space();
+  }
+
+  this._variance(node);
+
+  this.token("[");
+
+  if (node.id) {
+    this.print(node.id, node);
+    this.token(":");
+    this.space();
+  }
+
+  this.print(node.key, node);
+  this.token("]");
+  this.token(":");
+  this.space();
+  this.print(node.value, node);
+}
+
+function ObjectTypeProperty(node) {
+  if (node.proto) {
+    this.word("proto");
+    this.space();
+  }
+
+  if (node.static) {
+    this.word("static");
+    this.space();
+  }
+
+  if (node.kind === "get" || node.kind === "set") {
+    this.word(node.kind);
+    this.space();
+  }
+
+  this._variance(node);
+
+  this.print(node.key, node);
+  if (node.optional) this.token("?");
+
+  if (!node.method) {
+    this.token(":");
+    this.space();
+  }
+
+  this.print(node.value, node);
+}
+
+function ObjectTypeSpreadProperty(node) {
+  this.token("...");
+  this.print(node.argument, node);
+}
+
+function QualifiedTypeIdentifier(node) {
+  this.print(node.qualification, node);
+  this.token(".");
+  this.print(node.id, node);
+}
+
+function SymbolTypeAnnotation() {
+  this.word("symbol");
+}
+
+function orSeparator() {
+  this.space();
+  this.token("|");
+  this.space();
+}
+
+function UnionTypeAnnotation(node) {
+  this.printJoin(node.types, node, {
+    separator: orSeparator
+  });
+}
+
+function TypeCastExpression(node) {
+  this.token("(");
+  this.print(node.expression, node);
+  this.print(node.typeAnnotation, node);
+  this.token(")");
+}
+
+function Variance(node) {
+  if (node.kind === "plus") {
+    this.token("+");
+  } else {
+    this.token("-");
+  }
+}
+
+function VoidTypeAnnotation() {
+  this.word("void");
+}
+
+function IndexedAccessType(node) {
+  this.print(node.objectType, node);
+  this.token("[");
+  this.print(node.indexType, node);
+  this.token("]");
+}
+
+function OptionalIndexedAccessType(node) {
+  this.print(node.objectType, node);
+
+  if (node.optional) {
+    this.token("?.");
+  }
+
+  this.token("[");
+  this.print(node.indexType, node);
+  this.token("]");
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/generator/lib/generators/index.js

@@ -0,0 +1,148 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _templateLiterals = require("./template-literals");
+
+Object.keys(_templateLiterals).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _templateLiterals[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _templateLiterals[key];
+    }
+  });
+});
+
+var _expressions = require("./expressions");
+
+Object.keys(_expressions).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _expressions[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _expressions[key];
+    }
+  });
+});
+
+var _statements = require("./statements");
+
+Object.keys(_statements).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _statements[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _statements[key];
+    }
+  });
+});
+
+var _classes = require("./classes");
+
+Object.keys(_classes).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _classes[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _classes[key];
+    }
+  });
+});
+
+var _methods = require("./methods");
+
+Object.keys(_methods).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _methods[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _methods[key];
+    }
+  });
+});
+
+var _modules = require("./modules");
+
+Object.keys(_modules).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _modules[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _modules[key];
+    }
+  });
+});
+
+var _types = require("./types");
+
+Object.keys(_types).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _types[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _types[key];
+    }
+  });
+});
+
+var _flow = require("./flow");
+
+Object.keys(_flow).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _flow[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _flow[key];
+    }
+  });
+});
+
+var _base = require("./base");
+
+Object.keys(_base).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _base[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _base[key];
+    }
+  });
+});
+
+var _jsx = require("./jsx");
+
+Object.keys(_jsx).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _jsx[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _jsx[key];
+    }
+  });
+});
+
+var _typescript = require("./typescript");
+
+Object.keys(_typescript).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _typescript[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _typescript[key];
+    }
+  });
+});

node_modules/light-bolt11-decoder/examples/node_modules/@babel/generator/lib/generators/jsx.js

@@ -0,0 +1,145 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.JSXAttribute = JSXAttribute;
+exports.JSXClosingElement = JSXClosingElement;
+exports.JSXClosingFragment = JSXClosingFragment;
+exports.JSXElement = JSXElement;
+exports.JSXEmptyExpression = JSXEmptyExpression;
+exports.JSXExpressionContainer = JSXExpressionContainer;
+exports.JSXFragment = JSXFragment;
+exports.JSXIdentifier = JSXIdentifier;
+exports.JSXMemberExpression = JSXMemberExpression;
+exports.JSXNamespacedName = JSXNamespacedName;
+exports.JSXOpeningElement = JSXOpeningElement;
+exports.JSXOpeningFragment = JSXOpeningFragment;
+exports.JSXSpreadAttribute = JSXSpreadAttribute;
+exports.JSXSpreadChild = JSXSpreadChild;
+exports.JSXText = JSXText;
+
+function JSXAttribute(node) {
+  this.print(node.name, node);
+
+  if (node.value) {
+    this.token("=");
+    this.print(node.value, node);
+  }
+}
+
+function JSXIdentifier(node) {
+  this.word(node.name);
+}
+
+function JSXNamespacedName(node) {
+  this.print(node.namespace, node);
+  this.token(":");
+  this.print(node.name, node);
+}
+
+function JSXMemberExpression(node) {
+  this.print(node.object, node);
+  this.token(".");
+  this.print(node.property, node);
+}
+
+function JSXSpreadAttribute(node) {
+  this.token("{");
+  this.token("...");
+  this.print(node.argument, node);
+  this.token("}");
+}
+
+function JSXExpressionContainer(node) {
+  this.token("{");
+  this.print(node.expression, node);
+  this.token("}");
+}
+
+function JSXSpreadChild(node) {
+  this.token("{");
+  this.token("...");
+  this.print(node.expression, node);
+  this.token("}");
+}
+
+function JSXText(node) {
+  const raw = this.getPossibleRaw(node);
+
+  if (raw != null) {
+    this.token(raw);
+  } else {
+    this.token(node.value);
+  }
+}
+
+function JSXElement(node) {
+  const open = node.openingElement;
+  this.print(open, node);
+  if (open.selfClosing) return;
+  this.indent();
+
+  for (const child of node.children) {
+    this.print(child, node);
+  }
+
+  this.dedent();
+  this.print(node.closingElement, node);
+}
+
+function spaceSeparator() {
+  this.space();
+}
+
+function JSXOpeningElement(node) {
+  this.token("<");
+  this.print(node.name, node);
+  this.print(node.typeParameters, node);
+
+  if (node.attributes.length > 0) {
+    this.space();
+    this.printJoin(node.attributes, node, {
+      separator: spaceSeparator
+    });
+  }
+
+  if (node.selfClosing) {
+    this.space();
+    this.token("/>");
+  } else {
+    this.token(">");
+  }
+}
+
+function JSXClosingElement(node) {
+  this.token("</");
+  this.print(node.name, node);
+  this.token(">");
+}
+
+function JSXEmptyExpression(node) {
+  this.printInnerComments(node);
+}
+
+function JSXFragment(node) {
+  this.print(node.openingFragment, node);
+  this.indent();
+
+  for (const child of node.children) {
+    this.print(child, node);
+  }
+
+  this.dedent();
+  this.print(node.closingFragment, node);
+}
+
+function JSXOpeningFragment() {
+  this.token("<");
+  this.token(">");
+}
+
+function JSXClosingFragment() {
+  this.token("</");
+  this.token(">");
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/generator/lib/generators/methods.js

@@ -0,0 +1,150 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ArrowFunctionExpression = ArrowFunctionExpression;
+exports.FunctionDeclaration = exports.FunctionExpression = FunctionExpression;
+exports._functionHead = _functionHead;
+exports._methodHead = _methodHead;
+exports._param = _param;
+exports._parameters = _parameters;
+exports._params = _params;
+exports._predicate = _predicate;
+
+var _t = require("@babel/types");
+
+const {
+  isIdentifier
+} = _t;
+
+function _params(node) {
+  this.print(node.typeParameters, node);
+  this.token("(");
+
+  this._parameters(node.params, node);
+
+  this.token(")");
+  this.print(node.returnType, node);
+}
+
+function _parameters(parameters, parent) {
+  for (let i = 0; i < parameters.length; i++) {
+    this._param(parameters[i], parent);
+
+    if (i < parameters.length - 1) {
+      this.token(",");
+      this.space();
+    }
+  }
+}
+
+function _param(parameter, parent) {
+  this.printJoin(parameter.decorators, parameter);
+  this.print(parameter, parent);
+  if (parameter.optional) this.token("?");
+  this.print(parameter.typeAnnotation, parameter);
+}
+
+function _methodHead(node) {
+  const kind = node.kind;
+  const key = node.key;
+
+  if (kind === "get" || kind === "set") {
+    this.word(kind);
+    this.space();
+  }
+
+  if (node.async) {
+    this._catchUp("start", key.loc);
+
+    this.word("async");
+    this.space();
+  }
+
+  if (kind === "method" || kind === "init") {
+    if (node.generator) {
+      this.token("*");
+    }
+  }
+
+  if (node.computed) {
+    this.token("[");
+    this.print(key, node);
+    this.token("]");
+  } else {
+    this.print(key, node);
+  }
+
+  if (node.optional) {
+    this.token("?");
+  }
+
+  this._params(node);
+}
+
+function _predicate(node) {
+  if (node.predicate) {
+    if (!node.returnType) {
+      this.token(":");
+    }
+
+    this.space();
+    this.print(node.predicate, node);
+  }
+}
+
+function _functionHead(node) {
+  if (node.async) {
+    this.word("async");
+    this.space();
+  }
+
+  this.word("function");
+  if (node.generator) this.token("*");
+  this.printInnerComments(node);
+  this.space();
+
+  if (node.id) {
+    this.print(node.id, node);
+  }
+
+  this._params(node);
+
+  this._predicate(node);
+}
+
+function FunctionExpression(node) {
+  this._functionHead(node);
+
+  this.space();
+  this.print(node.body, node);
+}
+
+function ArrowFunctionExpression(node) {
+  if (node.async) {
+    this.word("async");
+    this.space();
+  }
+
+  const firstParam = node.params[0];
+
+  if (!this.format.retainLines && !this.format.auxiliaryCommentBefore && !this.format.auxiliaryCommentAfter && node.params.length === 1 && isIdentifier(firstParam) && !hasTypesOrComments(node, firstParam)) {
+    this.print(firstParam, node);
+  } else {
+    this._params(node);
+  }
+
+  this._predicate(node);
+
+  this.space();
+  this.token("=>");
+  this.space();
+  this.print(node.body, node);
+}
+
+function hasTypesOrComments(node, param) {
+  var _param$leadingComment, _param$trailingCommen;
+
+  return !!(node.typeParameters || node.returnType || node.predicate || param.typeAnnotation || param.optional || (_param$leadingComment = param.leadingComments) != null && _param$leadingComment.length || (_param$trailingCommen = param.trailingComments) != null && _param$trailingCommen.length);
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/generator/lib/generators/modules.js

@@ -0,0 +1,244 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ExportAllDeclaration = ExportAllDeclaration;
+exports.ExportDefaultDeclaration = ExportDefaultDeclaration;
+exports.ExportDefaultSpecifier = ExportDefaultSpecifier;
+exports.ExportNamedDeclaration = ExportNamedDeclaration;
+exports.ExportNamespaceSpecifier = ExportNamespaceSpecifier;
+exports.ExportSpecifier = ExportSpecifier;
+exports.ImportAttribute = ImportAttribute;
+exports.ImportDeclaration = ImportDeclaration;
+exports.ImportDefaultSpecifier = ImportDefaultSpecifier;
+exports.ImportNamespaceSpecifier = ImportNamespaceSpecifier;
+exports.ImportSpecifier = ImportSpecifier;
+
+var _t = require("@babel/types");
+
+const {
+  isClassDeclaration,
+  isExportDefaultSpecifier,
+  isExportNamespaceSpecifier,
+  isImportDefaultSpecifier,
+  isImportNamespaceSpecifier,
+  isStatement
+} = _t;
+
+function ImportSpecifier(node) {
+  if (node.importKind === "type" || node.importKind === "typeof") {
+    this.word(node.importKind);
+    this.space();
+  }
+
+  this.print(node.imported, node);
+
+  if (node.local && node.local.name !== node.imported.name) {
+    this.space();
+    this.word("as");
+    this.space();
+    this.print(node.local, node);
+  }
+}
+
+function ImportDefaultSpecifier(node) {
+  this.print(node.local, node);
+}
+
+function ExportDefaultSpecifier(node) {
+  this.print(node.exported, node);
+}
+
+function ExportSpecifier(node) {
+  if (node.exportKind === "type") {
+    this.word("type");
+    this.space();
+  }
+
+  this.print(node.local, node);
+
+  if (node.exported && node.local.name !== node.exported.name) {
+    this.space();
+    this.word("as");
+    this.space();
+    this.print(node.exported, node);
+  }
+}
+
+function ExportNamespaceSpecifier(node) {
+  this.token("*");
+  this.space();
+  this.word("as");
+  this.space();
+  this.print(node.exported, node);
+}
+
+function ExportAllDeclaration(node) {
+  this.word("export");
+  this.space();
+
+  if (node.exportKind === "type") {
+    this.word("type");
+    this.space();
+  }
+
+  this.token("*");
+  this.space();
+  this.word("from");
+  this.space();
+  this.print(node.source, node);
+  this.printAssertions(node);
+  this.semicolon();
+}
+
+function ExportNamedDeclaration(node) {
+  if (this.format.decoratorsBeforeExport && isClassDeclaration(node.declaration)) {
+    this.printJoin(node.declaration.decorators, node);
+  }
+
+  this.word("export");
+  this.space();
+  ExportDeclaration.apply(this, arguments);
+}
+
+function ExportDefaultDeclaration(node) {
+  if (this.format.decoratorsBeforeExport && isClassDeclaration(node.declaration)) {
+    this.printJoin(node.declaration.decorators, node);
+  }
+
+  this.word("export");
+  this.space();
+  this.word("default");
+  this.space();
+  ExportDeclaration.apply(this, arguments);
+}
+
+function ExportDeclaration(node) {
+  if (node.declaration) {
+    const declar = node.declaration;
+    this.print(declar, node);
+    if (!isStatement(declar)) this.semicolon();
+  } else {
+    if (node.exportKind === "type") {
+      this.word("type");
+      this.space();
+    }
+
+    const specifiers = node.specifiers.slice(0);
+    let hasSpecial = false;
+
+    for (;;) {
+      const first = specifiers[0];
+
+      if (isExportDefaultSpecifier(first) || isExportNamespaceSpecifier(first)) {
+        hasSpecial = true;
+        this.print(specifiers.shift(), node);
+
+        if (specifiers.length) {
+          this.token(",");
+          this.space();
+        }
+      } else {
+        break;
+      }
+    }
+
+    if (specifiers.length || !specifiers.length && !hasSpecial) {
+      this.token("{");
+
+      if (specifiers.length) {
+        this.space();
+        this.printList(specifiers, node);
+        this.space();
+      }
+
+      this.token("}");
+    }
+
+    if (node.source) {
+      this.space();
+      this.word("from");
+      this.space();
+      this.print(node.source, node);
+      this.printAssertions(node);
+    }
+
+    this.semicolon();
+  }
+}
+
+function ImportDeclaration(node) {
+  this.word("import");
+  this.space();
+  const isTypeKind = node.importKind === "type" || node.importKind === "typeof";
+
+  if (isTypeKind) {
+    this.word(node.importKind);
+    this.space();
+  }
+
+  const specifiers = node.specifiers.slice(0);
+  const hasSpecifiers = !!specifiers.length;
+
+  while (hasSpecifiers) {
+    const first = specifiers[0];
+
+    if (isImportDefaultSpecifier(first) || isImportNamespaceSpecifier(first)) {
+      this.print(specifiers.shift(), node);
+
+      if (specifiers.length) {
+        this.token(",");
+        this.space();
+      }
+    } else {
+      break;
+    }
+  }
+
+  if (specifiers.length) {
+    this.token("{");
+    this.space();
+    this.printList(specifiers, node);
+    this.space();
+    this.token("}");
+  } else if (isTypeKind && !hasSpecifiers) {
+    this.token("{");
+    this.token("}");
+  }
+
+  if (hasSpecifiers || isTypeKind) {
+    this.space();
+    this.word("from");
+    this.space();
+  }
+
+  this.print(node.source, node);
+  this.printAssertions(node);
+  {
+    var _node$attributes;
+
+    if ((_node$attributes = node.attributes) != null && _node$attributes.length) {
+      this.space();
+      this.word("with");
+      this.space();
+      this.printList(node.attributes, node);
+    }
+  }
+  this.semicolon();
+}
+
+function ImportAttribute(node) {
+  this.print(node.key);
+  this.token(":");
+  this.space();
+  this.print(node.value);
+}
+
+function ImportNamespaceSpecifier(node) {
+  this.token("*");
+  this.space();
+  this.word("as");
+  this.space();
+  this.print(node.local, node);
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/generator/lib/generators/statements.js

@@ -0,0 +1,331 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BreakStatement = void 0;
+exports.CatchClause = CatchClause;
+exports.ContinueStatement = void 0;
+exports.DebuggerStatement = DebuggerStatement;
+exports.DoWhileStatement = DoWhileStatement;
+exports.ForOfStatement = exports.ForInStatement = void 0;
+exports.ForStatement = ForStatement;
+exports.IfStatement = IfStatement;
+exports.LabeledStatement = LabeledStatement;
+exports.ReturnStatement = void 0;
+exports.SwitchCase = SwitchCase;
+exports.SwitchStatement = SwitchStatement;
+exports.ThrowStatement = void 0;
+exports.TryStatement = TryStatement;
+exports.VariableDeclaration = VariableDeclaration;
+exports.VariableDeclarator = VariableDeclarator;
+exports.WhileStatement = WhileStatement;
+exports.WithStatement = WithStatement;
+
+var _t = require("@babel/types");
+
+const {
+  isFor,
+  isForStatement,
+  isIfStatement,
+  isStatement
+} = _t;
+
+function WithStatement(node) {
+  this.word("with");
+  this.space();
+  this.token("(");
+  this.print(node.object, node);
+  this.token(")");
+  this.printBlock(node);
+}
+
+function IfStatement(node) {
+  this.word("if");
+  this.space();
+  this.token("(");
+  this.print(node.test, node);
+  this.token(")");
+  this.space();
+  const needsBlock = node.alternate && isIfStatement(getLastStatement(node.consequent));
+
+  if (needsBlock) {
+    this.token("{");
+    this.newline();
+    this.indent();
+  }
+
+  this.printAndIndentOnComments(node.consequent, node);
+
+  if (needsBlock) {
+    this.dedent();
+    this.newline();
+    this.token("}");
+  }
+
+  if (node.alternate) {
+    if (this.endsWith(125)) this.space();
+    this.word("else");
+    this.space();
+    this.printAndIndentOnComments(node.alternate, node);
+  }
+}
+
+function getLastStatement(statement) {
+  if (!isStatement(statement.body)) return statement;
+  return getLastStatement(statement.body);
+}
+
+function ForStatement(node) {
+  this.word("for");
+  this.space();
+  this.token("(");
+  this.inForStatementInitCounter++;
+  this.print(node.init, node);
+  this.inForStatementInitCounter--;
+  this.token(";");
+
+  if (node.test) {
+    this.space();
+    this.print(node.test, node);
+  }
+
+  this.token(";");
+
+  if (node.update) {
+    this.space();
+    this.print(node.update, node);
+  }
+
+  this.token(")");
+  this.printBlock(node);
+}
+
+function WhileStatement(node) {
+  this.word("while");
+  this.space();
+  this.token("(");
+  this.print(node.test, node);
+  this.token(")");
+  this.printBlock(node);
+}
+
+const buildForXStatement = function (op) {
+  return function (node) {
+    this.word("for");
+    this.space();
+
+    if (op === "of" && node.await) {
+      this.word("await");
+      this.space();
+    }
+
+    this.token("(");
+    this.print(node.left, node);
+    this.space();
+    this.word(op);
+    this.space();
+    this.print(node.right, node);
+    this.token(")");
+    this.printBlock(node);
+  };
+};
+
+const ForInStatement = buildForXStatement("in");
+exports.ForInStatement = ForInStatement;
+const ForOfStatement = buildForXStatement("of");
+exports.ForOfStatement = ForOfStatement;
+
+function DoWhileStatement(node) {
+  this.word("do");
+  this.space();
+  this.print(node.body, node);
+  this.space();
+  this.word("while");
+  this.space();
+  this.token("(");
+  this.print(node.test, node);
+  this.token(")");
+  this.semicolon();
+}
+
+function buildLabelStatement(prefix, key = "label") {
+  return function (node) {
+    this.word(prefix);
+    const label = node[key];
+
+    if (label) {
+      this.space();
+      const isLabel = key == "label";
+      const terminatorState = this.startTerminatorless(isLabel);
+      this.print(label, node);
+      this.endTerminatorless(terminatorState);
+    }
+
+    this.semicolon();
+  };
+}
+
+const ContinueStatement = buildLabelStatement("continue");
+exports.ContinueStatement = ContinueStatement;
+const ReturnStatement = buildLabelStatement("return", "argument");
+exports.ReturnStatement = ReturnStatement;
+const BreakStatement = buildLabelStatement("break");
+exports.BreakStatement = BreakStatement;
+const ThrowStatement = buildLabelStatement("throw", "argument");
+exports.ThrowStatement = ThrowStatement;
+
+function LabeledStatement(node) {
+  this.print(node.label, node);
+  this.token(":");
+  this.space();
+  this.print(node.body, node);
+}
+
+function TryStatement(node) {
+  this.word("try");
+  this.space();
+  this.print(node.block, node);
+  this.space();
+
+  if (node.handlers) {
+    this.print(node.handlers[0], node);
+  } else {
+    this.print(node.handler, node);
+  }
+
+  if (node.finalizer) {
+    this.space();
+    this.word("finally");
+    this.space();
+    this.print(node.finalizer, node);
+  }
+}
+
+function CatchClause(node) {
+  this.word("catch");
+  this.space();
+
+  if (node.param) {
+    this.token("(");
+    this.print(node.param, node);
+    this.print(node.param.typeAnnotation, node);
+    this.token(")");
+    this.space();
+  }
+
+  this.print(node.body, node);
+}
+
+function SwitchStatement(node) {
+  this.word("switch");
+  this.space();
+  this.token("(");
+  this.print(node.discriminant, node);
+  this.token(")");
+  this.space();
+  this.token("{");
+  this.printSequence(node.cases, node, {
+    indent: true,
+
+    addNewlines(leading, cas) {
+      if (!leading && node.cases[node.cases.length - 1] === cas) return -1;
+    }
+
+  });
+  this.token("}");
+}
+
+function SwitchCase(node) {
+  if (node.test) {
+    this.word("case");
+    this.space();
+    this.print(node.test, node);
+    this.token(":");
+  } else {
+    this.word("default");
+    this.token(":");
+  }
+
+  if (node.consequent.length) {
+    this.newline();
+    this.printSequence(node.consequent, node, {
+      indent: true
+    });
+  }
+}
+
+function DebuggerStatement() {
+  this.word("debugger");
+  this.semicolon();
+}
+
+function variableDeclarationIndent() {
+  this.token(",");
+  this.newline();
+
+  if (this.endsWith(10)) {
+    for (let i = 0; i < 4; i++) this.space(true);
+  }
+}
+
+function constDeclarationIndent() {
+  this.token(",");
+  this.newline();
+
+  if (this.endsWith(10)) {
+    for (let i = 0; i < 6; i++) this.space(true);
+  }
+}
+
+function VariableDeclaration(node, parent) {
+  if (node.declare) {
+    this.word("declare");
+    this.space();
+  }
+
+  this.word(node.kind);
+  this.space();
+  let hasInits = false;
+
+  if (!isFor(parent)) {
+    for (const declar of node.declarations) {
+      if (declar.init) {
+        hasInits = true;
+      }
+    }
+  }
+
+  let separator;
+
+  if (hasInits) {
+    separator = node.kind === "const" ? constDeclarationIndent : variableDeclarationIndent;
+  }
+
+  this.printList(node.declarations, node, {
+    separator
+  });
+
+  if (isFor(parent)) {
+    if (isForStatement(parent)) {
+      if (parent.init === node) return;
+    } else {
+      if (parent.left === node) return;
+    }
+  }
+
+  this.semicolon();
+}
+
+function VariableDeclarator(node) {
+  this.print(node.id, node);
+  if (node.definite) this.token("!");
+  this.print(node.id.typeAnnotation, node);
+
+  if (node.init) {
+    this.space();
+    this.token("=");
+    this.space();
+    this.print(node.init, node);
+  }
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/generator/lib/generators/template-literals.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TaggedTemplateExpression = TaggedTemplateExpression;
+exports.TemplateElement = TemplateElement;
+exports.TemplateLiteral = TemplateLiteral;
+
+function TaggedTemplateExpression(node) {
+  this.print(node.tag, node);
+  this.print(node.typeParameters, node);
+  this.print(node.quasi, node);
+}
+
+function TemplateElement(node, parent) {
+  const isFirst = parent.quasis[0] === node;
+  const isLast = parent.quasis[parent.quasis.length - 1] === node;
+  const value = (isFirst ? "`" : "}") + node.value.raw + (isLast ? "`" : "${");
+  this.token(value);
+}
+
+function TemplateLiteral(node) {
+  const quasis = node.quasis;
+
+  for (let i = 0; i < quasis.length; i++) {
+    this.print(quasis[i], node);
+
+    if (i + 1 < quasis.length) {
+      this.print(node.expressions[i], node);
+    }
+  }
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/generator/lib/generators/types.js

@@ -0,0 +1,276 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ArgumentPlaceholder = ArgumentPlaceholder;
+exports.ArrayPattern = exports.ArrayExpression = ArrayExpression;
+exports.BigIntLiteral = BigIntLiteral;
+exports.BooleanLiteral = BooleanLiteral;
+exports.DecimalLiteral = DecimalLiteral;
+exports.Identifier = Identifier;
+exports.NullLiteral = NullLiteral;
+exports.NumericLiteral = NumericLiteral;
+exports.ObjectPattern = exports.ObjectExpression = ObjectExpression;
+exports.ObjectMethod = ObjectMethod;
+exports.ObjectProperty = ObjectProperty;
+exports.PipelineBareFunction = PipelineBareFunction;
+exports.PipelinePrimaryTopicReference = PipelinePrimaryTopicReference;
+exports.PipelineTopicExpression = PipelineTopicExpression;
+exports.RecordExpression = RecordExpression;
+exports.RegExpLiteral = RegExpLiteral;
+exports.SpreadElement = exports.RestElement = RestElement;
+exports.StringLiteral = StringLiteral;
+exports.TopicReference = TopicReference;
+exports.TupleExpression = TupleExpression;
+
+var _t = require("@babel/types");
+
+var _jsesc = require("jsesc");
+
+const {
+  isAssignmentPattern,
+  isIdentifier
+} = _t;
+
+function Identifier(node) {
+  this.exactSource(node.loc, () => {
+    this.word(node.name);
+  });
+}
+
+function ArgumentPlaceholder() {
+  this.token("?");
+}
+
+function RestElement(node) {
+  this.token("...");
+  this.print(node.argument, node);
+}
+
+function ObjectExpression(node) {
+  const props = node.properties;
+  this.token("{");
+  this.printInnerComments(node);
+
+  if (props.length) {
+    this.space();
+    this.printList(props, node, {
+      indent: true,
+      statement: true
+    });
+    this.space();
+  }
+
+  this.token("}");
+}
+
+function ObjectMethod(node) {
+  this.printJoin(node.decorators, node);
+
+  this._methodHead(node);
+
+  this.space();
+  this.print(node.body, node);
+}
+
+function ObjectProperty(node) {
+  this.printJoin(node.decorators, node);
+
+  if (node.computed) {
+    this.token("[");
+    this.print(node.key, node);
+    this.token("]");
+  } else {
+    if (isAssignmentPattern(node.value) && isIdentifier(node.key) && node.key.name === node.value.left.name) {
+      this.print(node.value, node);
+      return;
+    }
+
+    this.print(node.key, node);
+
+    if (node.shorthand && isIdentifier(node.key) && isIdentifier(node.value) && node.key.name === node.value.name) {
+      return;
+    }
+  }
+
+  this.token(":");
+  this.space();
+  this.print(node.value, node);
+}
+
+function ArrayExpression(node) {
+  const elems = node.elements;
+  const len = elems.length;
+  this.token("[");
+  this.printInnerComments(node);
+
+  for (let i = 0; i < elems.length; i++) {
+    const elem = elems[i];
+
+    if (elem) {
+      if (i > 0) this.space();
+      this.print(elem, node);
+      if (i < len - 1) this.token(",");
+    } else {
+      this.token(",");
+    }
+  }
+
+  this.token("]");
+}
+
+function RecordExpression(node) {
+  const props = node.properties;
+  let startToken;
+  let endToken;
+
+  if (this.format.recordAndTupleSyntaxType === "bar") {
+    startToken = "{|";
+    endToken = "|}";
+  } else if (this.format.recordAndTupleSyntaxType === "hash") {
+    startToken = "#{";
+    endToken = "}";
+  } else {
+    throw new Error(`The "recordAndTupleSyntaxType" generator option must be "bar" or "hash" (${JSON.stringify(this.format.recordAndTupleSyntaxType)} received).`);
+  }
+
+  this.token(startToken);
+  this.printInnerComments(node);
+
+  if (props.length) {
+    this.space();
+    this.printList(props, node, {
+      indent: true,
+      statement: true
+    });
+    this.space();
+  }
+
+  this.token(endToken);
+}
+
+function TupleExpression(node) {
+  const elems = node.elements;
+  const len = elems.length;
+  let startToken;
+  let endToken;
+
+  if (this.format.recordAndTupleSyntaxType === "bar") {
+    startToken = "[|";
+    endToken = "|]";
+  } else if (this.format.recordAndTupleSyntaxType === "hash") {
+    startToken = "#[";
+    endToken = "]";
+  } else {
+    throw new Error(`${this.format.recordAndTupleSyntaxType} is not a valid recordAndTuple syntax type`);
+  }
+
+  this.token(startToken);
+  this.printInnerComments(node);
+
+  for (let i = 0; i < elems.length; i++) {
+    const elem = elems[i];
+
+    if (elem) {
+      if (i > 0) this.space();
+      this.print(elem, node);
+      if (i < len - 1) this.token(",");
+    }
+  }
+
+  this.token(endToken);
+}
+
+function RegExpLiteral(node) {
+  this.word(`/${node.pattern}/${node.flags}`);
+}
+
+function BooleanLiteral(node) {
+  this.word(node.value ? "true" : "false");
+}
+
+function NullLiteral() {
+  this.word("null");
+}
+
+function NumericLiteral(node) {
+  const raw = this.getPossibleRaw(node);
+  const opts = this.format.jsescOption;
+  const value = node.value + "";
+
+  if (opts.numbers) {
+    this.number(_jsesc(node.value, opts));
+  } else if (raw == null) {
+    this.number(value);
+  } else if (this.format.minified) {
+    this.number(raw.length < value.length ? raw : value);
+  } else {
+    this.number(raw);
+  }
+}
+
+function StringLiteral(node) {
+  const raw = this.getPossibleRaw(node);
+
+  if (!this.format.minified && raw != null) {
+    this.token(raw);
+    return;
+  }
+
+  const val = _jsesc(node.value, Object.assign(this.format.jsescOption, this.format.jsonCompatibleStrings && {
+    json: true
+  }));
+
+  return this.token(val);
+}
+
+function BigIntLiteral(node) {
+  const raw = this.getPossibleRaw(node);
+
+  if (!this.format.minified && raw != null) {
+    this.word(raw);
+    return;
+  }
+
+  this.word(node.value + "n");
+}
+
+function DecimalLiteral(node) {
+  const raw = this.getPossibleRaw(node);
+
+  if (!this.format.minified && raw != null) {
+    this.word(raw);
+    return;
+  }
+
+  this.word(node.value + "m");
+}
+
+const validTopicTokenSet = new Set(["^^", "@@", "^", "%", "#"]);
+
+function TopicReference() {
+  const {
+    topicToken
+  } = this.format;
+
+  if (validTopicTokenSet.has(topicToken)) {
+    this.token(topicToken);
+  } else {
+    const givenTopicTokenJSON = JSON.stringify(topicToken);
+    const validTopics = Array.from(validTopicTokenSet, v => JSON.stringify(v));
+    throw new Error(`The "topicToken" generator option must be one of ` + `${validTopics.join(", ")} (${givenTopicTokenJSON} received instead).`);
+  }
+}
+
+function PipelineTopicExpression(node) {
+  this.print(node.expression, node);
+}
+
+function PipelineBareFunction(node) {
+  this.print(node.callee, node);
+}
+
+function PipelinePrimaryTopicReference() {
+  this.token("#");
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/generator/lib/generators/typescript.js

@@ -0,0 +1,813 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TSAnyKeyword = TSAnyKeyword;
+exports.TSArrayType = TSArrayType;
+exports.TSAsExpression = TSAsExpression;
+exports.TSBigIntKeyword = TSBigIntKeyword;
+exports.TSBooleanKeyword = TSBooleanKeyword;
+exports.TSCallSignatureDeclaration = TSCallSignatureDeclaration;
+exports.TSConditionalType = TSConditionalType;
+exports.TSConstructSignatureDeclaration = TSConstructSignatureDeclaration;
+exports.TSConstructorType = TSConstructorType;
+exports.TSDeclareFunction = TSDeclareFunction;
+exports.TSDeclareMethod = TSDeclareMethod;
+exports.TSEnumDeclaration = TSEnumDeclaration;
+exports.TSEnumMember = TSEnumMember;
+exports.TSExportAssignment = TSExportAssignment;
+exports.TSExpressionWithTypeArguments = TSExpressionWithTypeArguments;
+exports.TSExternalModuleReference = TSExternalModuleReference;
+exports.TSFunctionType = TSFunctionType;
+exports.TSImportEqualsDeclaration = TSImportEqualsDeclaration;
+exports.TSImportType = TSImportType;
+exports.TSIndexSignature = TSIndexSignature;
+exports.TSIndexedAccessType = TSIndexedAccessType;
+exports.TSInferType = TSInferType;
+exports.TSInterfaceBody = TSInterfaceBody;
+exports.TSInterfaceDeclaration = TSInterfaceDeclaration;
+exports.TSIntersectionType = TSIntersectionType;
+exports.TSIntrinsicKeyword = TSIntrinsicKeyword;
+exports.TSLiteralType = TSLiteralType;
+exports.TSMappedType = TSMappedType;
+exports.TSMethodSignature = TSMethodSignature;
+exports.TSModuleBlock = TSModuleBlock;
+exports.TSModuleDeclaration = TSModuleDeclaration;
+exports.TSNamedTupleMember = TSNamedTupleMember;
+exports.TSNamespaceExportDeclaration = TSNamespaceExportDeclaration;
+exports.TSNeverKeyword = TSNeverKeyword;
+exports.TSNonNullExpression = TSNonNullExpression;
+exports.TSNullKeyword = TSNullKeyword;
+exports.TSNumberKeyword = TSNumberKeyword;
+exports.TSObjectKeyword = TSObjectKeyword;
+exports.TSOptionalType = TSOptionalType;
+exports.TSParameterProperty = TSParameterProperty;
+exports.TSParenthesizedType = TSParenthesizedType;
+exports.TSPropertySignature = TSPropertySignature;
+exports.TSQualifiedName = TSQualifiedName;
+exports.TSRestType = TSRestType;
+exports.TSStringKeyword = TSStringKeyword;
+exports.TSSymbolKeyword = TSSymbolKeyword;
+exports.TSThisType = TSThisType;
+exports.TSTupleType = TSTupleType;
+exports.TSTypeAliasDeclaration = TSTypeAliasDeclaration;
+exports.TSTypeAnnotation = TSTypeAnnotation;
+exports.TSTypeAssertion = TSTypeAssertion;
+exports.TSTypeLiteral = TSTypeLiteral;
+exports.TSTypeOperator = TSTypeOperator;
+exports.TSTypeParameter = TSTypeParameter;
+exports.TSTypeParameterDeclaration = exports.TSTypeParameterInstantiation = TSTypeParameterInstantiation;
+exports.TSTypePredicate = TSTypePredicate;
+exports.TSTypeQuery = TSTypeQuery;
+exports.TSTypeReference = TSTypeReference;
+exports.TSUndefinedKeyword = TSUndefinedKeyword;
+exports.TSUnionType = TSUnionType;
+exports.TSUnknownKeyword = TSUnknownKeyword;
+exports.TSVoidKeyword = TSVoidKeyword;
+exports.tsPrintBraced = tsPrintBraced;
+exports.tsPrintClassMemberModifiers = tsPrintClassMemberModifiers;
+exports.tsPrintFunctionOrConstructorType = tsPrintFunctionOrConstructorType;
+exports.tsPrintPropertyOrMethodName = tsPrintPropertyOrMethodName;
+exports.tsPrintSignatureDeclarationBase = tsPrintSignatureDeclarationBase;
+exports.tsPrintTypeLiteralOrInterfaceBody = tsPrintTypeLiteralOrInterfaceBody;
+exports.tsPrintUnionOrIntersectionType = tsPrintUnionOrIntersectionType;
+
+function TSTypeAnnotation(node) {
+  this.token(":");
+  this.space();
+  if (node.optional) this.token("?");
+  this.print(node.typeAnnotation, node);
+}
+
+function TSTypeParameterInstantiation(node, parent) {
+  this.token("<");
+  this.printList(node.params, node, {});
+
+  if (parent.type === "ArrowFunctionExpression" && node.params.length === 1) {
+    this.token(",");
+  }
+
+  this.token(">");
+}
+
+function TSTypeParameter(node) {
+  this.word(node.name);
+
+  if (node.constraint) {
+    this.space();
+    this.word("extends");
+    this.space();
+    this.print(node.constraint, node);
+  }
+
+  if (node.default) {
+    this.space();
+    this.token("=");
+    this.space();
+    this.print(node.default, node);
+  }
+}
+
+function TSParameterProperty(node) {
+  if (node.accessibility) {
+    this.word(node.accessibility);
+    this.space();
+  }
+
+  if (node.readonly) {
+    this.word("readonly");
+    this.space();
+  }
+
+  this._param(node.parameter);
+}
+
+function TSDeclareFunction(node) {
+  if (node.declare) {
+    this.word("declare");
+    this.space();
+  }
+
+  this._functionHead(node);
+
+  this.token(";");
+}
+
+function TSDeclareMethod(node) {
+  this._classMethodHead(node);
+
+  this.token(";");
+}
+
+function TSQualifiedName(node) {
+  this.print(node.left, node);
+  this.token(".");
+  this.print(node.right, node);
+}
+
+function TSCallSignatureDeclaration(node) {
+  this.tsPrintSignatureDeclarationBase(node);
+  this.token(";");
+}
+
+function TSConstructSignatureDeclaration(node) {
+  this.word("new");
+  this.space();
+  this.tsPrintSignatureDeclarationBase(node);
+  this.token(";");
+}
+
+function TSPropertySignature(node) {
+  const {
+    readonly,
+    initializer
+  } = node;
+
+  if (readonly) {
+    this.word("readonly");
+    this.space();
+  }
+
+  this.tsPrintPropertyOrMethodName(node);
+  this.print(node.typeAnnotation, node);
+
+  if (initializer) {
+    this.space();
+    this.token("=");
+    this.space();
+    this.print(initializer, node);
+  }
+
+  this.token(";");
+}
+
+function tsPrintPropertyOrMethodName(node) {
+  if (node.computed) {
+    this.token("[");
+  }
+
+  this.print(node.key, node);
+
+  if (node.computed) {
+    this.token("]");
+  }
+
+  if (node.optional) {
+    this.token("?");
+  }
+}
+
+function TSMethodSignature(node) {
+  const {
+    kind
+  } = node;
+
+  if (kind === "set" || kind === "get") {
+    this.word(kind);
+    this.space();
+  }
+
+  this.tsPrintPropertyOrMethodName(node);
+  this.tsPrintSignatureDeclarationBase(node);
+  this.token(";");
+}
+
+function TSIndexSignature(node) {
+  const {
+    readonly,
+    static: isStatic
+  } = node;
+
+  if (isStatic) {
+    this.word("static");
+    this.space();
+  }
+
+  if (readonly) {
+    this.word("readonly");
+    this.space();
+  }
+
+  this.token("[");
+
+  this._parameters(node.parameters, node);
+
+  this.token("]");
+  this.print(node.typeAnnotation, node);
+  this.token(";");
+}
+
+function TSAnyKeyword() {
+  this.word("any");
+}
+
+function TSBigIntKeyword() {
+  this.word("bigint");
+}
+
+function TSUnknownKeyword() {
+  this.word("unknown");
+}
+
+function TSNumberKeyword() {
+  this.word("number");
+}
+
+function TSObjectKeyword() {
+  this.word("object");
+}
+
+function TSBooleanKeyword() {
+  this.word("boolean");
+}
+
+function TSStringKeyword() {
+  this.word("string");
+}
+
+function TSSymbolKeyword() {
+  this.word("symbol");
+}
+
+function TSVoidKeyword() {
+  this.word("void");
+}
+
+function TSUndefinedKeyword() {
+  this.word("undefined");
+}
+
+function TSNullKeyword() {
+  this.word("null");
+}
+
+function TSNeverKeyword() {
+  this.word("never");
+}
+
+function TSIntrinsicKeyword() {
+  this.word("intrinsic");
+}
+
+function TSThisType() {
+  this.word("this");
+}
+
+function TSFunctionType(node) {
+  this.tsPrintFunctionOrConstructorType(node);
+}
+
+function TSConstructorType(node) {
+  if (node.abstract) {
+    this.word("abstract");
+    this.space();
+  }
+
+  this.word("new");
+  this.space();
+  this.tsPrintFunctionOrConstructorType(node);
+}
+
+function tsPrintFunctionOrConstructorType(node) {
+  const {
+    typeParameters
+  } = node;
+  const parameters = node.parameters;
+  this.print(typeParameters, node);
+  this.token("(");
+
+  this._parameters(parameters, node);
+
+  this.token(")");
+  this.space();
+  this.token("=>");
+  this.space();
+  const returnType = node.typeAnnotation;
+  this.print(returnType.typeAnnotation, node);
+}
+
+function TSTypeReference(node) {
+  this.print(node.typeName, node);
+  this.print(node.typeParameters, node);
+}
+
+function TSTypePredicate(node) {
+  if (node.asserts) {
+    this.word("asserts");
+    this.space();
+  }
+
+  this.print(node.parameterName);
+
+  if (node.typeAnnotation) {
+    this.space();
+    this.word("is");
+    this.space();
+    this.print(node.typeAnnotation.typeAnnotation);
+  }
+}
+
+function TSTypeQuery(node) {
+  this.word("typeof");
+  this.space();
+  this.print(node.exprName);
+}
+
+function TSTypeLiteral(node) {
+  this.tsPrintTypeLiteralOrInterfaceBody(node.members, node);
+}
+
+function tsPrintTypeLiteralOrInterfaceBody(members, node) {
+  this.tsPrintBraced(members, node);
+}
+
+function tsPrintBraced(members, node) {
+  this.token("{");
+
+  if (members.length) {
+    this.indent();
+    this.newline();
+
+    for (const member of members) {
+      this.print(member, node);
+      this.newline();
+    }
+
+    this.dedent();
+    this.rightBrace();
+  } else {
+    this.token("}");
+  }
+}
+
+function TSArrayType(node) {
+  this.print(node.elementType, node);
+  this.token("[]");
+}
+
+function TSTupleType(node) {
+  this.token("[");
+  this.printList(node.elementTypes, node);
+  this.token("]");
+}
+
+function TSOptionalType(node) {
+  this.print(node.typeAnnotation, node);
+  this.token("?");
+}
+
+function TSRestType(node) {
+  this.token("...");
+  this.print(node.typeAnnotation, node);
+}
+
+function TSNamedTupleMember(node) {
+  this.print(node.label, node);
+  if (node.optional) this.token("?");
+  this.token(":");
+  this.space();
+  this.print(node.elementType, node);
+}
+
+function TSUnionType(node) {
+  this.tsPrintUnionOrIntersectionType(node, "|");
+}
+
+function TSIntersectionType(node) {
+  this.tsPrintUnionOrIntersectionType(node, "&");
+}
+
+function tsPrintUnionOrIntersectionType(node, sep) {
+  this.printJoin(node.types, node, {
+    separator() {
+      this.space();
+      this.token(sep);
+      this.space();
+    }
+
+  });
+}
+
+function TSConditionalType(node) {
+  this.print(node.checkType);
+  this.space();
+  this.word("extends");
+  this.space();
+  this.print(node.extendsType);
+  this.space();
+  this.token("?");
+  this.space();
+  this.print(node.trueType);
+  this.space();
+  this.token(":");
+  this.space();
+  this.print(node.falseType);
+}
+
+function TSInferType(node) {
+  this.token("infer");
+  this.space();
+  this.print(node.typeParameter);
+}
+
+function TSParenthesizedType(node) {
+  this.token("(");
+  this.print(node.typeAnnotation, node);
+  this.token(")");
+}
+
+function TSTypeOperator(node) {
+  this.word(node.operator);
+  this.space();
+  this.print(node.typeAnnotation, node);
+}
+
+function TSIndexedAccessType(node) {
+  this.print(node.objectType, node);
+  this.token("[");
+  this.print(node.indexType, node);
+  this.token("]");
+}
+
+function TSMappedType(node) {
+  const {
+    nameType,
+    optional,
+    readonly,
+    typeParameter
+  } = node;
+  this.token("{");
+  this.space();
+
+  if (readonly) {
+    tokenIfPlusMinus(this, readonly);
+    this.word("readonly");
+    this.space();
+  }
+
+  this.token("[");
+  this.word(typeParameter.name);
+  this.space();
+  this.word("in");
+  this.space();
+  this.print(typeParameter.constraint, typeParameter);
+
+  if (nameType) {
+    this.space();
+    this.word("as");
+    this.space();
+    this.print(nameType, node);
+  }
+
+  this.token("]");
+
+  if (optional) {
+    tokenIfPlusMinus(this, optional);
+    this.token("?");
+  }
+
+  this.token(":");
+  this.space();
+  this.print(node.typeAnnotation, node);
+  this.space();
+  this.token("}");
+}
+
+function tokenIfPlusMinus(self, tok) {
+  if (tok !== true) {
+    self.token(tok);
+  }
+}
+
+function TSLiteralType(node) {
+  this.print(node.literal, node);
+}
+
+function TSExpressionWithTypeArguments(node) {
+  this.print(node.expression, node);
+  this.print(node.typeParameters, node);
+}
+
+function TSInterfaceDeclaration(node) {
+  const {
+    declare,
+    id,
+    typeParameters,
+    extends: extendz,
+    body
+  } = node;
+
+  if (declare) {
+    this.word("declare");
+    this.space();
+  }
+
+  this.word("interface");
+  this.space();
+  this.print(id, node);
+  this.print(typeParameters, node);
+
+  if (extendz != null && extendz.length) {
+    this.space();
+    this.word("extends");
+    this.space();
+    this.printList(extendz, node);
+  }
+
+  this.space();
+  this.print(body, node);
+}
+
+function TSInterfaceBody(node) {
+  this.tsPrintTypeLiteralOrInterfaceBody(node.body, node);
+}
+
+function TSTypeAliasDeclaration(node) {
+  const {
+    declare,
+    id,
+    typeParameters,
+    typeAnnotation
+  } = node;
+
+  if (declare) {
+    this.word("declare");
+    this.space();
+  }
+
+  this.word("type");
+  this.space();
+  this.print(id, node);
+  this.print(typeParameters, node);
+  this.space();
+  this.token("=");
+  this.space();
+  this.print(typeAnnotation, node);
+  this.token(";");
+}
+
+function TSAsExpression(node) {
+  const {
+    expression,
+    typeAnnotation
+  } = node;
+  this.print(expression, node);
+  this.space();
+  this.word("as");
+  this.space();
+  this.print(typeAnnotation, node);
+}
+
+function TSTypeAssertion(node) {
+  const {
+    typeAnnotation,
+    expression
+  } = node;
+  this.token("<");
+  this.print(typeAnnotation, node);
+  this.token(">");
+  this.space();
+  this.print(expression, node);
+}
+
+function TSEnumDeclaration(node) {
+  const {
+    declare,
+    const: isConst,
+    id,
+    members
+  } = node;
+
+  if (declare) {
+    this.word("declare");
+    this.space();
+  }
+
+  if (isConst) {
+    this.word("const");
+    this.space();
+  }
+
+  this.word("enum");
+  this.space();
+  this.print(id, node);
+  this.space();
+  this.tsPrintBraced(members, node);
+}
+
+function TSEnumMember(node) {
+  const {
+    id,
+    initializer
+  } = node;
+  this.print(id, node);
+
+  if (initializer) {
+    this.space();
+    this.token("=");
+    this.space();
+    this.print(initializer, node);
+  }
+
+  this.token(",");
+}
+
+function TSModuleDeclaration(node) {
+  const {
+    declare,
+    id
+  } = node;
+
+  if (declare) {
+    this.word("declare");
+    this.space();
+  }
+
+  if (!node.global) {
+    this.word(id.type === "Identifier" ? "namespace" : "module");
+    this.space();
+  }
+
+  this.print(id, node);
+
+  if (!node.body) {
+    this.token(";");
+    return;
+  }
+
+  let body = node.body;
+
+  while (body.type === "TSModuleDeclaration") {
+    this.token(".");
+    this.print(body.id, body);
+    body = body.body;
+  }
+
+  this.space();
+  this.print(body, node);
+}
+
+function TSModuleBlock(node) {
+  this.tsPrintBraced(node.body, node);
+}
+
+function TSImportType(node) {
+  const {
+    argument,
+    qualifier,
+    typeParameters
+  } = node;
+  this.word("import");
+  this.token("(");
+  this.print(argument, node);
+  this.token(")");
+
+  if (qualifier) {
+    this.token(".");
+    this.print(qualifier, node);
+  }
+
+  if (typeParameters) {
+    this.print(typeParameters, node);
+  }
+}
+
+function TSImportEqualsDeclaration(node) {
+  const {
+    isExport,
+    id,
+    moduleReference
+  } = node;
+
+  if (isExport) {
+    this.word("export");
+    this.space();
+  }
+
+  this.word("import");
+  this.space();
+  this.print(id, node);
+  this.space();
+  this.token("=");
+  this.space();
+  this.print(moduleReference, node);
+  this.token(";");
+}
+
+function TSExternalModuleReference(node) {
+  this.token("require(");
+  this.print(node.expression, node);
+  this.token(")");
+}
+
+function TSNonNullExpression(node) {
+  this.print(node.expression, node);
+  this.token("!");
+}
+
+function TSExportAssignment(node) {
+  this.word("export");
+  this.space();
+  this.token("=");
+  this.space();
+  this.print(node.expression, node);
+  this.token(";");
+}
+
+function TSNamespaceExportDeclaration(node) {
+  this.word("export");
+  this.space();
+  this.word("as");
+  this.space();
+  this.word("namespace");
+  this.space();
+  this.print(node.id, node);
+}
+
+function tsPrintSignatureDeclarationBase(node) {
+  const {
+    typeParameters
+  } = node;
+  const parameters = node.parameters;
+  this.print(typeParameters, node);
+  this.token("(");
+
+  this._parameters(parameters, node);
+
+  this.token(")");
+  const returnType = node.typeAnnotation;
+  this.print(returnType, node);
+}
+
+function tsPrintClassMemberModifiers(node, isField) {
+  if (isField && node.declare) {
+    this.word("declare");
+    this.space();
+  }
+
+  if (node.accessibility) {
+    this.word(node.accessibility);
+    this.space();
+  }
+
+  if (node.static) {
+    this.word("static");
+    this.space();
+  }
+
+  if (node.override) {
+    this.word("override");
+    this.space();
+  }
+
+  if (node.abstract) {
+    this.word("abstract");
+    this.space();
+  }
+
+  if (isField && node.readonly) {
+    this.word("readonly");
+    this.space();
+  }
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/generator/lib/index.js

@@ -0,0 +1,97 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CodeGenerator = void 0;
+exports.default = generate;
+
+var _sourceMap = require("./source-map");
+
+var _printer = require("./printer");
+
+class Generator extends _printer.default {
+  constructor(ast, opts = {}, code) {
+    const format = normalizeOptions(code, opts);
+    const map = opts.sourceMaps ? new _sourceMap.default(opts, code) : null;
+    super(format, map);
+    this.ast = void 0;
+    this.ast = ast;
+  }
+
+  generate() {
+    return super.generate(this.ast);
+  }
+
+}
+
+function normalizeOptions(code, opts) {
+  const format = {
+    auxiliaryCommentBefore: opts.auxiliaryCommentBefore,
+    auxiliaryCommentAfter: opts.auxiliaryCommentAfter,
+    shouldPrintComment: opts.shouldPrintComment,
+    retainLines: opts.retainLines,
+    retainFunctionParens: opts.retainFunctionParens,
+    comments: opts.comments == null || opts.comments,
+    compact: opts.compact,
+    minified: opts.minified,
+    concise: opts.concise,
+    indent: {
+      adjustMultilineComment: true,
+      style: "  ",
+      base: 0
+    },
+    decoratorsBeforeExport: !!opts.decoratorsBeforeExport,
+    jsescOption: Object.assign({
+      quotes: "double",
+      wrap: true,
+      minimal: false
+    }, opts.jsescOption),
+    recordAndTupleSyntaxType: opts.recordAndTupleSyntaxType,
+    topicToken: opts.topicToken
+  };
+  {
+    format.jsonCompatibleStrings = opts.jsonCompatibleStrings;
+  }
+
+  if (format.minified) {
+    format.compact = true;
+
+    format.shouldPrintComment = format.shouldPrintComment || (() => format.comments);
+  } else {
+    format.shouldPrintComment = format.shouldPrintComment || (value => format.comments || value.indexOf("@license") >= 0 || value.indexOf("@preserve") >= 0);
+  }
+
+  if (format.compact === "auto") {
+    format.compact = code.length > 500000;
+
+    if (format.compact) {
+      console.error("[BABEL] Note: The code generator has deoptimised the styling of " + `${opts.filename} as it exceeds the max of ${"500KB"}.`);
+    }
+  }
+
+  if (format.compact) {
+    format.indent.adjustMultilineComment = false;
+  }
+
+  return format;
+}
+
+class CodeGenerator {
+  constructor(ast, opts, code) {
+    this._generator = void 0;
+    this._generator = new Generator(ast, opts, code);
+  }
+
+  generate() {
+    return this._generator.generate();
+  }
+
+}
+
+exports.CodeGenerator = CodeGenerator;
+
+function generate(ast, opts, code) {
+  const gen = new Generator(ast, opts, code);
+  return gen.generate();
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/generator/lib/node/index.js

@@ -0,0 +1,111 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.needsParens = needsParens;
+exports.needsWhitespace = needsWhitespace;
+exports.needsWhitespaceAfter = needsWhitespaceAfter;
+exports.needsWhitespaceBefore = needsWhitespaceBefore;
+
+var whitespace = require("./whitespace");
+
+var parens = require("./parentheses");
+
+var _t = require("@babel/types");
+
+const {
+  FLIPPED_ALIAS_KEYS,
+  isCallExpression,
+  isExpressionStatement,
+  isMemberExpression,
+  isNewExpression
+} = _t;
+
+function expandAliases(obj) {
+  const newObj = {};
+
+  function add(type, func) {
+    const fn = newObj[type];
+    newObj[type] = fn ? function (node, parent, stack) {
+      const result = fn(node, parent, stack);
+      return result == null ? func(node, parent, stack) : result;
+    } : func;
+  }
+
+  for (const type of Object.keys(obj)) {
+    const aliases = FLIPPED_ALIAS_KEYS[type];
+
+    if (aliases) {
+      for (const alias of aliases) {
+        add(alias, obj[type]);
+      }
+    } else {
+      add(type, obj[type]);
+    }
+  }
+
+  return newObj;
+}
+
+const expandedParens = expandAliases(parens);
+const expandedWhitespaceNodes = expandAliases(whitespace.nodes);
+const expandedWhitespaceList = expandAliases(whitespace.list);
+
+function find(obj, node, parent, printStack) {
+  const fn = obj[node.type];
+  return fn ? fn(node, parent, printStack) : null;
+}
+
+function isOrHasCallExpression(node) {
+  if (isCallExpression(node)) {
+    return true;
+  }
+
+  return isMemberExpression(node) && isOrHasCallExpression(node.object);
+}
+
+function needsWhitespace(node, parent, type) {
+  if (!node) return 0;
+
+  if (isExpressionStatement(node)) {
+    node = node.expression;
+  }
+
+  let linesInfo = find(expandedWhitespaceNodes, node, parent);
+
+  if (!linesInfo) {
+    const items = find(expandedWhitespaceList, node, parent);
+
+    if (items) {
+      for (let i = 0; i < items.length; i++) {
+        linesInfo = needsWhitespace(items[i], node, type);
+        if (linesInfo) break;
+      }
+    }
+  }
+
+  if (typeof linesInfo === "object" && linesInfo !== null) {
+    return linesInfo[type] || 0;
+  }
+
+  return 0;
+}
+
+function needsWhitespaceBefore(node, parent) {
+  return needsWhitespace(node, parent, "before");
+}
+
+function needsWhitespaceAfter(node, parent) {
+  return needsWhitespace(node, parent, "after");
+}
+
+function needsParens(node, parent, printStack) {
+  if (!parent) return false;
+
+  if (isNewExpression(parent) && parent.callee === node) {
+    if (isOrHasCallExpression(node)) return true;
+  }
+
+  return find(expandedParens, node, parent, printStack);
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/generator/lib/node/parentheses.js

@@ -0,0 +1,342 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ArrowFunctionExpression = ArrowFunctionExpression;
+exports.AssignmentExpression = AssignmentExpression;
+exports.Binary = Binary;
+exports.BinaryExpression = BinaryExpression;
+exports.ClassExpression = ClassExpression;
+exports.ConditionalExpression = ConditionalExpression;
+exports.DoExpression = DoExpression;
+exports.FunctionExpression = FunctionExpression;
+exports.FunctionTypeAnnotation = FunctionTypeAnnotation;
+exports.Identifier = Identifier;
+exports.LogicalExpression = LogicalExpression;
+exports.NullableTypeAnnotation = NullableTypeAnnotation;
+exports.ObjectExpression = ObjectExpression;
+exports.OptionalIndexedAccessType = OptionalIndexedAccessType;
+exports.OptionalCallExpression = exports.OptionalMemberExpression = OptionalMemberExpression;
+exports.SequenceExpression = SequenceExpression;
+exports.TSAsExpression = TSAsExpression;
+exports.TSInferType = TSInferType;
+exports.TSTypeAssertion = TSTypeAssertion;
+exports.TSIntersectionType = exports.TSUnionType = TSUnionType;
+exports.UnaryLike = UnaryLike;
+exports.IntersectionTypeAnnotation = exports.UnionTypeAnnotation = UnionTypeAnnotation;
+exports.UpdateExpression = UpdateExpression;
+exports.AwaitExpression = exports.YieldExpression = YieldExpression;
+
+var _t = require("@babel/types");
+
+const {
+  isArrayTypeAnnotation,
+  isArrowFunctionExpression,
+  isAssignmentExpression,
+  isAwaitExpression,
+  isBinary,
+  isBinaryExpression,
+  isCallExpression,
+  isClassDeclaration,
+  isClassExpression,
+  isConditional,
+  isConditionalExpression,
+  isExportDeclaration,
+  isExportDefaultDeclaration,
+  isExpressionStatement,
+  isFor,
+  isForInStatement,
+  isForOfStatement,
+  isForStatement,
+  isIfStatement,
+  isIndexedAccessType,
+  isIntersectionTypeAnnotation,
+  isLogicalExpression,
+  isMemberExpression,
+  isNewExpression,
+  isNullableTypeAnnotation,
+  isObjectPattern,
+  isOptionalCallExpression,
+  isOptionalMemberExpression,
+  isReturnStatement,
+  isSequenceExpression,
+  isSwitchStatement,
+  isTSArrayType,
+  isTSAsExpression,
+  isTSIntersectionType,
+  isTSNonNullExpression,
+  isTSOptionalType,
+  isTSRestType,
+  isTSTypeAssertion,
+  isTSUnionType,
+  isTaggedTemplateExpression,
+  isThrowStatement,
+  isTypeAnnotation,
+  isUnaryLike,
+  isUnionTypeAnnotation,
+  isVariableDeclarator,
+  isWhileStatement,
+  isYieldExpression
+} = _t;
+const PRECEDENCE = {
+  "||": 0,
+  "??": 0,
+  "&&": 1,
+  "|": 2,
+  "^": 3,
+  "&": 4,
+  "==": 5,
+  "===": 5,
+  "!=": 5,
+  "!==": 5,
+  "<": 6,
+  ">": 6,
+  "<=": 6,
+  ">=": 6,
+  in: 6,
+  instanceof: 6,
+  ">>": 7,
+  "<<": 7,
+  ">>>": 7,
+  "+": 8,
+  "-": 8,
+  "*": 9,
+  "/": 9,
+  "%": 9,
+  "**": 10
+};
+
+const isClassExtendsClause = (node, parent) => (isClassDeclaration(parent) || isClassExpression(parent)) && parent.superClass === node;
+
+const hasPostfixPart = (node, parent) => (isMemberExpression(parent) || isOptionalMemberExpression(parent)) && parent.object === node || (isCallExpression(parent) || isOptionalCallExpression(parent) || isNewExpression(parent)) && parent.callee === node || isTaggedTemplateExpression(parent) && parent.tag === node || isTSNonNullExpression(parent);
+
+function NullableTypeAnnotation(node, parent) {
+  return isArrayTypeAnnotation(parent);
+}
+
+function FunctionTypeAnnotation(node, parent, printStack) {
+  return isUnionTypeAnnotation(parent) || isIntersectionTypeAnnotation(parent) || isArrayTypeAnnotation(parent) || isTypeAnnotation(parent) && isArrowFunctionExpression(printStack[printStack.length - 3]);
+}
+
+function UpdateExpression(node, parent) {
+  return hasPostfixPart(node, parent) || isClassExtendsClause(node, parent);
+}
+
+function ObjectExpression(node, parent, printStack) {
+  return isFirstInContext(printStack, {
+    expressionStatement: true,
+    arrowBody: true
+  });
+}
+
+function DoExpression(node, parent, printStack) {
+  return !node.async && isFirstInContext(printStack, {
+    expressionStatement: true
+  });
+}
+
+function Binary(node, parent) {
+  if (node.operator === "**" && isBinaryExpression(parent, {
+    operator: "**"
+  })) {
+    return parent.left === node;
+  }
+
+  if (isClassExtendsClause(node, parent)) {
+    return true;
+  }
+
+  if (hasPostfixPart(node, parent) || isUnaryLike(parent) || isAwaitExpression(parent)) {
+    return true;
+  }
+
+  if (isBinary(parent)) {
+    const parentOp = parent.operator;
+    const parentPos = PRECEDENCE[parentOp];
+    const nodeOp = node.operator;
+    const nodePos = PRECEDENCE[nodeOp];
+
+    if (parentPos === nodePos && parent.right === node && !isLogicalExpression(parent) || parentPos > nodePos) {
+      return true;
+    }
+  }
+}
+
+function UnionTypeAnnotation(node, parent) {
+  return isArrayTypeAnnotation(parent) || isNullableTypeAnnotation(parent) || isIntersectionTypeAnnotation(parent) || isUnionTypeAnnotation(parent);
+}
+
+function OptionalIndexedAccessType(node, parent) {
+  return isIndexedAccessType(parent, {
+    objectType: node
+  });
+}
+
+function TSAsExpression() {
+  return true;
+}
+
+function TSTypeAssertion() {
+  return true;
+}
+
+function TSUnionType(node, parent) {
+  return isTSArrayType(parent) || isTSOptionalType(parent) || isTSIntersectionType(parent) || isTSUnionType(parent) || isTSRestType(parent);
+}
+
+function TSInferType(node, parent) {
+  return isTSArrayType(parent) || isTSOptionalType(parent);
+}
+
+function BinaryExpression(node, parent) {
+  return node.operator === "in" && (isVariableDeclarator(parent) || isFor(parent));
+}
+
+function SequenceExpression(node, parent) {
+  if (isForStatement(parent) || isThrowStatement(parent) || isReturnStatement(parent) || isIfStatement(parent) && parent.test === node || isWhileStatement(parent) && parent.test === node || isForInStatement(parent) && parent.right === node || isSwitchStatement(parent) && parent.discriminant === node || isExpressionStatement(parent) && parent.expression === node) {
+    return false;
+  }
+
+  return true;
+}
+
+function YieldExpression(node, parent) {
+  return isBinary(parent) || isUnaryLike(parent) || hasPostfixPart(node, parent) || isAwaitExpression(parent) && isYieldExpression(node) || isConditionalExpression(parent) && node === parent.test || isClassExtendsClause(node, parent);
+}
+
+function ClassExpression(node, parent, printStack) {
+  return isFirstInContext(printStack, {
+    expressionStatement: true,
+    exportDefault: true
+  });
+}
+
+function UnaryLike(node, parent) {
+  return hasPostfixPart(node, parent) || isBinaryExpression(parent, {
+    operator: "**",
+    left: node
+  }) || isClassExtendsClause(node, parent);
+}
+
+function FunctionExpression(node, parent, printStack) {
+  return isFirstInContext(printStack, {
+    expressionStatement: true,
+    exportDefault: true
+  });
+}
+
+function ArrowFunctionExpression(node, parent) {
+  return isExportDeclaration(parent) || ConditionalExpression(node, parent);
+}
+
+function ConditionalExpression(node, parent) {
+  if (isUnaryLike(parent) || isBinary(parent) || isConditionalExpression(parent, {
+    test: node
+  }) || isAwaitExpression(parent) || isTSTypeAssertion(parent) || isTSAsExpression(parent)) {
+    return true;
+  }
+
+  return UnaryLike(node, parent);
+}
+
+function OptionalMemberExpression(node, parent) {
+  return isCallExpression(parent, {
+    callee: node
+  }) || isMemberExpression(parent, {
+    object: node
+  });
+}
+
+function AssignmentExpression(node, parent) {
+  if (isObjectPattern(node.left)) {
+    return true;
+  } else {
+    return ConditionalExpression(node, parent);
+  }
+}
+
+function LogicalExpression(node, parent) {
+  switch (node.operator) {
+    case "||":
+      if (!isLogicalExpression(parent)) return false;
+      return parent.operator === "??" || parent.operator === "&&";
+
+    case "&&":
+      return isLogicalExpression(parent, {
+        operator: "??"
+      });
+
+    case "??":
+      return isLogicalExpression(parent) && parent.operator !== "??";
+  }
+}
+
+function Identifier(node, parent, printStack) {
+  if (node.name === "let") {
+    const isFollowedByBracket = isMemberExpression(parent, {
+      object: node,
+      computed: true
+    }) || isOptionalMemberExpression(parent, {
+      object: node,
+      computed: true,
+      optional: false
+    });
+    return isFirstInContext(printStack, {
+      expressionStatement: isFollowedByBracket,
+      forHead: isFollowedByBracket,
+      forInHead: isFollowedByBracket,
+      forOfHead: true
+    });
+  }
+
+  return node.name === "async" && isForOfStatement(parent) && node === parent.left;
+}
+
+function isFirstInContext(printStack, {
+  expressionStatement = false,
+  arrowBody = false,
+  exportDefault = false,
+  forHead = false,
+  forInHead = false,
+  forOfHead = false
+}) {
+  let i = printStack.length - 1;
+  let node = printStack[i];
+  i--;
+  let parent = printStack[i];
+
+  while (i >= 0) {
+    if (expressionStatement && isExpressionStatement(parent, {
+      expression: node
+    }) || exportDefault && isExportDefaultDeclaration(parent, {
+      declaration: node
+    }) || arrowBody && isArrowFunctionExpression(parent, {
+      body: node
+    }) || forHead && isForStatement(parent, {
+      init: node
+    }) || forInHead && isForInStatement(parent, {
+      left: node
+    }) || forOfHead && isForOfStatement(parent, {
+      left: node
+    })) {
+      return true;
+    }
+
+    if (hasPostfixPart(node, parent) && !isNewExpression(parent) || isSequenceExpression(parent) && parent.expressions[0] === node || isConditional(parent, {
+      test: node
+    }) || isBinary(parent, {
+      left: node
+    }) || isAssignmentExpression(parent, {
+      left: node
+    })) {
+      node = parent;
+      i--;
+      parent = printStack[i];
+    } else {
+      return false;
+    }
+  }
+
+  return false;
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/generator/lib/node/whitespace.js

@@ -0,0 +1,214 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.nodes = exports.list = void 0;
+
+var _t = require("@babel/types");
+
+const {
+  FLIPPED_ALIAS_KEYS,
+  isArrayExpression,
+  isAssignmentExpression,
+  isBinary,
+  isBlockStatement,
+  isCallExpression,
+  isFunction,
+  isIdentifier,
+  isLiteral,
+  isMemberExpression,
+  isObjectExpression,
+  isOptionalCallExpression,
+  isOptionalMemberExpression,
+  isStringLiteral
+} = _t;
+
+function crawl(node, state = {}) {
+  if (isMemberExpression(node) || isOptionalMemberExpression(node)) {
+    crawl(node.object, state);
+    if (node.computed) crawl(node.property, state);
+  } else if (isBinary(node) || isAssignmentExpression(node)) {
+    crawl(node.left, state);
+    crawl(node.right, state);
+  } else if (isCallExpression(node) || isOptionalCallExpression(node)) {
+    state.hasCall = true;
+    crawl(node.callee, state);
+  } else if (isFunction(node)) {
+    state.hasFunction = true;
+  } else if (isIdentifier(node)) {
+    state.hasHelper = state.hasHelper || isHelper(node.callee);
+  }
+
+  return state;
+}
+
+function isHelper(node) {
+  if (isMemberExpression(node)) {
+    return isHelper(node.object) || isHelper(node.property);
+  } else if (isIdentifier(node)) {
+    return node.name === "require" || node.name[0] === "_";
+  } else if (isCallExpression(node)) {
+    return isHelper(node.callee);
+  } else if (isBinary(node) || isAssignmentExpression(node)) {
+    return isIdentifier(node.left) && isHelper(node.left) || isHelper(node.right);
+  } else {
+    return false;
+  }
+}
+
+function isType(node) {
+  return isLiteral(node) || isObjectExpression(node) || isArrayExpression(node) || isIdentifier(node) || isMemberExpression(node);
+}
+
+const nodes = {
+  AssignmentExpression(node) {
+    const state = crawl(node.right);
+
+    if (state.hasCall && state.hasHelper || state.hasFunction) {
+      return {
+        before: state.hasFunction,
+        after: true
+      };
+    }
+  },
+
+  SwitchCase(node, parent) {
+    return {
+      before: !!node.consequent.length || parent.cases[0] === node,
+      after: !node.consequent.length && parent.cases[parent.cases.length - 1] === node
+    };
+  },
+
+  LogicalExpression(node) {
+    if (isFunction(node.left) || isFunction(node.right)) {
+      return {
+        after: true
+      };
+    }
+  },
+
+  Literal(node) {
+    if (isStringLiteral(node) && node.value === "use strict") {
+      return {
+        after: true
+      };
+    }
+  },
+
+  CallExpression(node) {
+    if (isFunction(node.callee) || isHelper(node)) {
+      return {
+        before: true,
+        after: true
+      };
+    }
+  },
+
+  OptionalCallExpression(node) {
+    if (isFunction(node.callee)) {
+      return {
+        before: true,
+        after: true
+      };
+    }
+  },
+
+  VariableDeclaration(node) {
+    for (let i = 0; i < node.declarations.length; i++) {
+      const declar = node.declarations[i];
+      let enabled = isHelper(declar.id) && !isType(declar.init);
+
+      if (!enabled) {
+        const state = crawl(declar.init);
+        enabled = isHelper(declar.init) && state.hasCall || state.hasFunction;
+      }
+
+      if (enabled) {
+        return {
+          before: true,
+          after: true
+        };
+      }
+    }
+  },
+
+  IfStatement(node) {
+    if (isBlockStatement(node.consequent)) {
+      return {
+        before: true,
+        after: true
+      };
+    }
+  }
+
+};
+exports.nodes = nodes;
+
+nodes.ObjectProperty = nodes.ObjectTypeProperty = nodes.ObjectMethod = function (node, parent) {
+  if (parent.properties[0] === node) {
+    return {
+      before: true
+    };
+  }
+};
+
+nodes.ObjectTypeCallProperty = function (node, parent) {
+  var _parent$properties;
+
+  if (parent.callProperties[0] === node && !((_parent$properties = parent.properties) != null && _parent$properties.length)) {
+    return {
+      before: true
+    };
+  }
+};
+
+nodes.ObjectTypeIndexer = function (node, parent) {
+  var _parent$properties2, _parent$callPropertie;
+
+  if (parent.indexers[0] === node && !((_parent$properties2 = parent.properties) != null && _parent$properties2.length) && !((_parent$callPropertie = parent.callProperties) != null && _parent$callPropertie.length)) {
+    return {
+      before: true
+    };
+  }
+};
+
+nodes.ObjectTypeInternalSlot = function (node, parent) {
+  var _parent$properties3, _parent$callPropertie2, _parent$indexers;
+
+  if (parent.internalSlots[0] === node && !((_parent$properties3 = parent.properties) != null && _parent$properties3.length) && !((_parent$callPropertie2 = parent.callProperties) != null && _parent$callPropertie2.length) && !((_parent$indexers = parent.indexers) != null && _parent$indexers.length)) {
+    return {
+      before: true
+    };
+  }
+};
+
+const list = {
+  VariableDeclaration(node) {
+    return node.declarations.map(decl => decl.init);
+  },
+
+  ArrayExpression(node) {
+    return node.elements;
+  },
+
+  ObjectExpression(node) {
+    return node.properties;
+  }
+
+};
+exports.list = list;
+[["Function", true], ["Class", true], ["Loop", true], ["LabeledStatement", true], ["SwitchStatement", true], ["TryStatement", true]].forEach(function ([type, amounts]) {
+  if (typeof amounts === "boolean") {
+    amounts = {
+      after: amounts,
+      before: amounts
+    };
+  }
+
+  [type].concat(FLIPPED_ALIAS_KEYS[type] || []).forEach(function (type) {
+    nodes[type] = function () {
+      return amounts;
+    };
+  });
+});

node_modules/light-bolt11-decoder/examples/node_modules/@babel/generator/lib/printer.js

@@ -0,0 +1,540 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _buffer = require("./buffer");
+
+var n = require("./node");
+
+var _t = require("@babel/types");
+
+var generatorFunctions = require("./generators");
+
+const {
+  isProgram,
+  isFile,
+  isEmptyStatement
+} = _t;
+const SCIENTIFIC_NOTATION = /e/i;
+const ZERO_DECIMAL_INTEGER = /\.0+$/;
+const NON_DECIMAL_LITERAL = /^0[box]/;
+const PURE_ANNOTATION_RE = /^\s*[@#]__PURE__\s*$/;
+const {
+  needsParens,
+  needsWhitespaceAfter,
+  needsWhitespaceBefore
+} = n;
+
+class Printer {
+  constructor(format, map) {
+    this.inForStatementInitCounter = 0;
+    this._printStack = [];
+    this._indent = 0;
+    this._insideAux = false;
+    this._parenPushNewlineState = null;
+    this._noLineTerminator = false;
+    this._printAuxAfterOnNextUserNode = false;
+    this._printedComments = new WeakSet();
+    this._endsWithInteger = false;
+    this._endsWithWord = false;
+    this.format = format;
+    this._buf = new _buffer.default(map);
+  }
+
+  generate(ast) {
+    this.print(ast);
+
+    this._maybeAddAuxComment();
+
+    return this._buf.get();
+  }
+
+  indent() {
+    if (this.format.compact || this.format.concise) return;
+    this._indent++;
+  }
+
+  dedent() {
+    if (this.format.compact || this.format.concise) return;
+    this._indent--;
+  }
+
+  semicolon(force = false) {
+    this._maybeAddAuxComment();
+
+    this._append(";", !force);
+  }
+
+  rightBrace() {
+    if (this.format.minified) {
+      this._buf.removeLastSemicolon();
+    }
+
+    this.token("}");
+  }
+
+  space(force = false) {
+    if (this.format.compact) return;
+
+    if (force) {
+      this._space();
+    } else if (this._buf.hasContent()) {
+      const lastCp = this.getLastChar();
+
+      if (lastCp !== 32 && lastCp !== 10) {
+        this._space();
+      }
+    }
+  }
+
+  word(str) {
+    if (this._endsWithWord || this.endsWith(47) && str.charCodeAt(0) === 47) {
+      this._space();
+    }
+
+    this._maybeAddAuxComment();
+
+    this._append(str);
+
+    this._endsWithWord = true;
+  }
+
+  number(str) {
+    this.word(str);
+    this._endsWithInteger = Number.isInteger(+str) && !NON_DECIMAL_LITERAL.test(str) && !SCIENTIFIC_NOTATION.test(str) && !ZERO_DECIMAL_INTEGER.test(str) && str.charCodeAt(str.length - 1) !== 46;
+  }
+
+  token(str) {
+    const lastChar = this.getLastChar();
+    const strFirst = str.charCodeAt(0);
+
+    if (str === "--" && lastChar === 33 || strFirst === 43 && lastChar === 43 || strFirst === 45 && lastChar === 45 || strFirst === 46 && this._endsWithInteger) {
+      this._space();
+    }
+
+    this._maybeAddAuxComment();
+
+    this._append(str);
+  }
+
+  newline(i = 1) {
+    if (this.format.retainLines || this.format.compact) return;
+
+    if (this.format.concise) {
+      this.space();
+      return;
+    }
+
+    const charBeforeNewline = this.endsWithCharAndNewline();
+    if (charBeforeNewline === 10) return;
+
+    if (charBeforeNewline === 123 || charBeforeNewline === 58) {
+      i--;
+    }
+
+    if (i <= 0) return;
+
+    for (let j = 0; j < i; j++) {
+      this._newline();
+    }
+  }
+
+  endsWith(char) {
+    return this.getLastChar() === char;
+  }
+
+  getLastChar() {
+    return this._buf.getLastChar();
+  }
+
+  endsWithCharAndNewline() {
+    return this._buf.endsWithCharAndNewline();
+  }
+
+  removeTrailingNewline() {
+    this._buf.removeTrailingNewline();
+  }
+
+  exactSource(loc, cb) {
+    this._catchUp("start", loc);
+
+    this._buf.exactSource(loc, cb);
+  }
+
+  source(prop, loc) {
+    this._catchUp(prop, loc);
+
+    this._buf.source(prop, loc);
+  }
+
+  withSource(prop, loc, cb) {
+    this._catchUp(prop, loc);
+
+    this._buf.withSource(prop, loc, cb);
+  }
+
+  _space() {
+    this._append(" ", true);
+  }
+
+  _newline() {
+    this._append("\n", true);
+  }
+
+  _append(str, queue = false) {
+    this._maybeAddParen(str);
+
+    this._maybeIndent(str);
+
+    if (queue) this._buf.queue(str);else this._buf.append(str);
+    this._endsWithWord = false;
+    this._endsWithInteger = false;
+  }
+
+  _maybeIndent(str) {
+    if (this._indent && this.endsWith(10) && str.charCodeAt(0) !== 10) {
+      this._buf.queue(this._getIndent());
+    }
+  }
+
+  _maybeAddParen(str) {
+    const parenPushNewlineState = this._parenPushNewlineState;
+    if (!parenPushNewlineState) return;
+    let i;
+
+    for (i = 0; i < str.length && str[i] === " "; i++) continue;
+
+    if (i === str.length) {
+      return;
+    }
+
+    const cha = str[i];
+
+    if (cha !== "\n") {
+      if (cha !== "/" || i + 1 === str.length) {
+        this._parenPushNewlineState = null;
+        return;
+      }
+
+      const chaPost = str[i + 1];
+
+      if (chaPost === "*") {
+        if (PURE_ANNOTATION_RE.test(str.slice(i + 2, str.length - 2))) {
+          return;
+        }
+      } else if (chaPost !== "/") {
+        this._parenPushNewlineState = null;
+        return;
+      }
+    }
+
+    this.token("(");
+    this.indent();
+    parenPushNewlineState.printed = true;
+  }
+
+  _catchUp(prop, loc) {
+    if (!this.format.retainLines) return;
+    const pos = loc ? loc[prop] : null;
+
+    if ((pos == null ? void 0 : pos.line) != null) {
+      const count = pos.line - this._buf.getCurrentLine();
+
+      for (let i = 0; i < count; i++) {
+        this._newline();
+      }
+    }
+  }
+
+  _getIndent() {
+    return this.format.indent.style.repeat(this._indent);
+  }
+
+  startTerminatorless(isLabel = false) {
+    if (isLabel) {
+      this._noLineTerminator = true;
+      return null;
+    } else {
+      return this._parenPushNewlineState = {
+        printed: false
+      };
+    }
+  }
+
+  endTerminatorless(state) {
+    this._noLineTerminator = false;
+
+    if (state != null && state.printed) {
+      this.dedent();
+      this.newline();
+      this.token(")");
+    }
+  }
+
+  print(node, parent) {
+    if (!node) return;
+    const oldConcise = this.format.concise;
+
+    if (node._compact) {
+      this.format.concise = true;
+    }
+
+    const printMethod = this[node.type];
+
+    if (!printMethod) {
+      throw new ReferenceError(`unknown node of type ${JSON.stringify(node.type)} with constructor ${JSON.stringify(node == null ? void 0 : node.constructor.name)}`);
+    }
+
+    this._printStack.push(node);
+
+    const oldInAux = this._insideAux;
+    this._insideAux = !node.loc;
+
+    this._maybeAddAuxComment(this._insideAux && !oldInAux);
+
+    let shouldPrintParens = needsParens(node, parent, this._printStack);
+
+    if (this.format.retainFunctionParens && node.type === "FunctionExpression" && node.extra && node.extra.parenthesized) {
+      shouldPrintParens = true;
+    }
+
+    if (shouldPrintParens) this.token("(");
+
+    this._printLeadingComments(node);
+
+    const loc = isProgram(node) || isFile(node) ? null : node.loc;
+    this.withSource("start", loc, () => {
+      printMethod.call(this, node, parent);
+    });
+
+    this._printTrailingComments(node);
+
+    if (shouldPrintParens) this.token(")");
+
+    this._printStack.pop();
+
+    this.format.concise = oldConcise;
+    this._insideAux = oldInAux;
+  }
+
+  _maybeAddAuxComment(enteredPositionlessNode) {
+    if (enteredPositionlessNode) this._printAuxBeforeComment();
+    if (!this._insideAux) this._printAuxAfterComment();
+  }
+
+  _printAuxBeforeComment() {
+    if (this._printAuxAfterOnNextUserNode) return;
+    this._printAuxAfterOnNextUserNode = true;
+    const comment = this.format.auxiliaryCommentBefore;
+
+    if (comment) {
+      this._printComment({
+        type: "CommentBlock",
+        value: comment
+      });
+    }
+  }
+
+  _printAuxAfterComment() {
+    if (!this._printAuxAfterOnNextUserNode) return;
+    this._printAuxAfterOnNextUserNode = false;
+    const comment = this.format.auxiliaryCommentAfter;
+
+    if (comment) {
+      this._printComment({
+        type: "CommentBlock",
+        value: comment
+      });
+    }
+  }
+
+  getPossibleRaw(node) {
+    const extra = node.extra;
+
+    if (extra && extra.raw != null && extra.rawValue != null && node.value === extra.rawValue) {
+      return extra.raw;
+    }
+  }
+
+  printJoin(nodes, parent, opts = {}) {
+    if (!(nodes != null && nodes.length)) return;
+    if (opts.indent) this.indent();
+    const newlineOpts = {
+      addNewlines: opts.addNewlines
+    };
+
+    for (let i = 0; i < nodes.length; i++) {
+      const node = nodes[i];
+      if (!node) continue;
+      if (opts.statement) this._printNewline(true, node, parent, newlineOpts);
+      this.print(node, parent);
+
+      if (opts.iterator) {
+        opts.iterator(node, i);
+      }
+
+      if (opts.separator && i < nodes.length - 1) {
+        opts.separator.call(this);
+      }
+
+      if (opts.statement) this._printNewline(false, node, parent, newlineOpts);
+    }
+
+    if (opts.indent) this.dedent();
+  }
+
+  printAndIndentOnComments(node, parent) {
+    const indent = node.leadingComments && node.leadingComments.length > 0;
+    if (indent) this.indent();
+    this.print(node, parent);
+    if (indent) this.dedent();
+  }
+
+  printBlock(parent) {
+    const node = parent.body;
+
+    if (!isEmptyStatement(node)) {
+      this.space();
+    }
+
+    this.print(node, parent);
+  }
+
+  _printTrailingComments(node) {
+    this._printComments(this._getComments(false, node));
+  }
+
+  _printLeadingComments(node) {
+    this._printComments(this._getComments(true, node), true);
+  }
+
+  printInnerComments(node, indent = true) {
+    var _node$innerComments;
+
+    if (!((_node$innerComments = node.innerComments) != null && _node$innerComments.length)) return;
+    if (indent) this.indent();
+
+    this._printComments(node.innerComments);
+
+    if (indent) this.dedent();
+  }
+
+  printSequence(nodes, parent, opts = {}) {
+    opts.statement = true;
+    return this.printJoin(nodes, parent, opts);
+  }
+
+  printList(items, parent, opts = {}) {
+    if (opts.separator == null) {
+      opts.separator = commaSeparator;
+    }
+
+    return this.printJoin(items, parent, opts);
+  }
+
+  _printNewline(leading, node, parent, opts) {
+    if (this.format.retainLines || this.format.compact) return;
+
+    if (this.format.concise) {
+      this.space();
+      return;
+    }
+
+    let lines = 0;
+
+    if (this._buf.hasContent()) {
+      if (!leading) lines++;
+      if (opts.addNewlines) lines += opts.addNewlines(leading, node) || 0;
+      const needs = leading ? needsWhitespaceBefore : needsWhitespaceAfter;
+      if (needs(node, parent)) lines++;
+    }
+
+    this.newline(Math.min(2, lines));
+  }
+
+  _getComments(leading, node) {
+    return node && (leading ? node.leadingComments : node.trailingComments) || [];
+  }
+
+  _printComment(comment, skipNewLines) {
+    if (!this.format.shouldPrintComment(comment.value)) return;
+    if (comment.ignore) return;
+    if (this._printedComments.has(comment)) return;
+
+    this._printedComments.add(comment);
+
+    const isBlockComment = comment.type === "CommentBlock";
+    const printNewLines = isBlockComment && !skipNewLines && !this._noLineTerminator;
+    if (printNewLines && this._buf.hasContent()) this.newline(1);
+    const lastCharCode = this.getLastChar();
+
+    if (lastCharCode !== 91 && lastCharCode !== 123) {
+      this.space();
+    }
+
+    let val = !isBlockComment && !this._noLineTerminator ? `//${comment.value}\n` : `/*${comment.value}*/`;
+
+    if (isBlockComment && this.format.indent.adjustMultilineComment) {
+      var _comment$loc;
+
+      const offset = (_comment$loc = comment.loc) == null ? void 0 : _comment$loc.start.column;
+
+      if (offset) {
+        const newlineRegex = new RegExp("\\n\\s{1," + offset + "}", "g");
+        val = val.replace(newlineRegex, "\n");
+      }
+
+      const indentSize = Math.max(this._getIndent().length, this.format.retainLines ? 0 : this._buf.getCurrentColumn());
+      val = val.replace(/\n(?!$)/g, `\n${" ".repeat(indentSize)}`);
+    }
+
+    if (this.endsWith(47)) this._space();
+    this.withSource("start", comment.loc, () => {
+      this._append(val);
+    });
+    if (printNewLines) this.newline(1);
+  }
+
+  _printComments(comments, inlinePureAnnotation) {
+    if (!(comments != null && comments.length)) return;
+
+    if (inlinePureAnnotation && comments.length === 1 && PURE_ANNOTATION_RE.test(comments[0].value)) {
+      this._printComment(comments[0], this._buf.hasContent() && !this.endsWith(10));
+    } else {
+      for (const comment of comments) {
+        this._printComment(comment);
+      }
+    }
+  }
+
+  printAssertions(node) {
+    var _node$assertions;
+
+    if ((_node$assertions = node.assertions) != null && _node$assertions.length) {
+      this.space();
+      this.word("assert");
+      this.space();
+      this.token("{");
+      this.space();
+      this.printList(node.assertions, node);
+      this.space();
+      this.token("}");
+    }
+  }
+
+}
+
+Object.assign(Printer.prototype, generatorFunctions);
+{
+  Printer.prototype.Noop = function Noop() {};
+}
+var _default = Printer;
+exports.default = _default;
+
+function commaSeparator() {
+  this.token(",");
+  this.space();
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/generator/lib/source-map.js

@@ -0,0 +1,78 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _sourceMap = require("source-map");
+
+class SourceMap {
+  constructor(opts, code) {
+    this._cachedMap = void 0;
+    this._code = void 0;
+    this._opts = void 0;
+    this._rawMappings = void 0;
+    this._lastGenLine = void 0;
+    this._lastSourceLine = void 0;
+    this._lastSourceColumn = void 0;
+    this._cachedMap = null;
+    this._code = code;
+    this._opts = opts;
+    this._rawMappings = [];
+  }
+
+  get() {
+    if (!this._cachedMap) {
+      const map = this._cachedMap = new _sourceMap.SourceMapGenerator({
+        sourceRoot: this._opts.sourceRoot
+      });
+      const code = this._code;
+
+      if (typeof code === "string") {
+        map.setSourceContent(this._opts.sourceFileName.replace(/\\/g, "/"), code);
+      } else if (typeof code === "object") {
+        Object.keys(code).forEach(sourceFileName => {
+          map.setSourceContent(sourceFileName.replace(/\\/g, "/"), code[sourceFileName]);
+        });
+      }
+
+      this._rawMappings.forEach(mapping => map.addMapping(mapping), map);
+    }
+
+    return this._cachedMap.toJSON();
+  }
+
+  getRawMappings() {
+    return this._rawMappings.slice();
+  }
+
+  mark(generatedLine, generatedColumn, line, column, identifierName, filename, force) {
+    if (this._lastGenLine !== generatedLine && line === null) return;
+
+    if (!force && this._lastGenLine === generatedLine && this._lastSourceLine === line && this._lastSourceColumn === column) {
+      return;
+    }
+
+    this._cachedMap = null;
+    this._lastGenLine = generatedLine;
+    this._lastSourceLine = line;
+    this._lastSourceColumn = column;
+
+    this._rawMappings.push({
+      name: identifierName || undefined,
+      generated: {
+        line: generatedLine,
+        column: generatedColumn
+      },
+      source: line == null ? undefined : (filename || this._opts.sourceFileName).replace(/\\/g, "/"),
+      original: line == null ? undefined : {
+        line: line,
+        column: column
+      }
+    });
+  }
+
+}
+
+exports.default = SourceMap;

node_modules/light-bolt11-decoder/examples/node_modules/@babel/generator/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@babel/generator",
+  "version": "7.17.9",
+  "description": "Turns an AST into code.",
+  "author": "The Babel Team (https://babel.dev/team)",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-generator"
+  },
+  "homepage": "https://babel.dev/docs/en/next/babel-generator",
+  "bugs": "https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20generator%22+is%3Aopen",
+  "main": "./lib/index.js",
+  "files": [
+    "lib"
+  ],
+  "dependencies": {
+    "@babel/types": "^7.17.0",
+    "jsesc": "^2.5.1",
+    "source-map": "^0.5.0"
+  },
+  "devDependencies": {
+    "@babel/helper-fixtures": "^7.17.0",
+    "@babel/parser": "^7.17.9",
+    "@jridgewell/trace-mapping": "^0.3.4",
+    "@types/jsesc": "^2.5.0",
+    "@types/source-map": "^0.5.0",
+    "charcodes": "^0.2.0"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  }
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/helper-annotate-as-pure/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/light-bolt11-decoder/examples/node_modules/@babel/helper-annotate-as-pure/README.md

@@ -0,0 +1,19 @@
+# @babel/helper-annotate-as-pure
+
+> Helper function to annotate paths and nodes with #__PURE__ comment
+
+See our website [@babel/helper-annotate-as-pure](https://babeljs.io/docs/en/babel-helper-annotate-as-pure) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save @babel/helper-annotate-as-pure
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/helper-annotate-as-pure
+```

node_modules/light-bolt11-decoder/examples/node_modules/@babel/helper-annotate-as-pure/lib/index.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = annotateAsPure;
+
+var _t = require("@babel/types");
+
+const {
+  addComment
+} = _t;
+const PURE_ANNOTATION = "#__PURE__";
+
+const isPureAnnotated = ({
+  leadingComments
+}) => !!leadingComments && leadingComments.some(comment => /[@#]__PURE__/.test(comment.value));
+
+function annotateAsPure(pathOrNode) {
+  const node = pathOrNode["node"] || pathOrNode;
+
+  if (isPureAnnotated(node)) {
+    return;
+  }
+
+  addComment(node, "leading", PURE_ANNOTATION);
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/helper-annotate-as-pure/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@babel/helper-annotate-as-pure",
+  "version": "7.16.7",
+  "description": "Helper function to annotate paths and nodes with #__PURE__ comment",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-helper-annotate-as-pure"
+  },
+  "homepage": "https://babel.dev/docs/en/next/babel-helper-annotate-as-pure",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./lib/index.js",
+  "dependencies": {
+    "@babel/types": "^7.16.7"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "author": "The Babel Team (https://babel.dev/team)"
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/helper-environment-visitor/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/light-bolt11-decoder/examples/node_modules/@babel/helper-environment-visitor/README.md

@@ -0,0 +1,19 @@
+# @babel/helper-environment-visitor
+
+> Helper visitor to only visit nodes in the current 'this' context
+
+See our website [@babel/helper-environment-visitor](https://babeljs.io/docs/en/babel-helper-environment-visitor) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/helper-environment-visitor
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/helper-environment-visitor --dev
+```

node_modules/light-bolt11-decoder/examples/node_modules/@babel/helper-environment-visitor/lib/index.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.skipAllButComputedKey = skipAllButComputedKey;
+
+var _t = require("@babel/types");
+
+const {
+  VISITOR_KEYS,
+  staticBlock
+} = _t;
+
+function skipAllButComputedKey(path) {
+  if (!path.node.computed) {
+    path.skip();
+    return;
+  }
+
+  const keys = VISITOR_KEYS[path.type];
+
+  for (const key of keys) {
+    if (key !== "key") path.skipKey(key);
+  }
+}
+
+const skipKey = (staticBlock ? "StaticBlock|" : "") + "ClassPrivateProperty|TypeAnnotation|FunctionDeclaration|FunctionExpression";
+var _default = {
+  [skipKey]: path => path.skip(),
+
+  "Method|ClassProperty"(path) {
+    skipAllButComputedKey(path);
+  }
+
+};
+exports.default = _default;

node_modules/light-bolt11-decoder/examples/node_modules/@babel/helper-environment-visitor/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@babel/helper-environment-visitor",
+  "version": "7.16.7",
+  "description": "Helper visitor to only visit nodes in the current 'this' context",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-helper-environment-visitor"
+  },
+  "homepage": "https://babel.dev/docs/en/next/babel-helper-environment-visitor",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@babel/types": "^7.16.7"
+  },
+  "devDependencies": {
+    "@babel/traverse": "^7.16.7"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "author": "The Babel Team (https://babel.dev/team)"
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/helper-function-name/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/light-bolt11-decoder/examples/node_modules/@babel/helper-function-name/README.md

@@ -0,0 +1,19 @@
+# @babel/helper-function-name
+
+> Helper function to change the property 'name' of every function
+
+See our website [@babel/helper-function-name](https://babeljs.io/docs/en/babel-helper-function-name) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save @babel/helper-function-name
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/helper-function-name
+```

node_modules/light-bolt11-decoder/examples/node_modules/@babel/helper-function-name/lib/index.js

@@ -0,0 +1,198 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+
+var _template = require("@babel/template");
+
+var _t = require("@babel/types");
+
+const {
+  NOT_LOCAL_BINDING,
+  cloneNode,
+  identifier,
+  isAssignmentExpression,
+  isAssignmentPattern,
+  isFunction,
+  isIdentifier,
+  isLiteral,
+  isNullLiteral,
+  isObjectMethod,
+  isObjectProperty,
+  isRegExpLiteral,
+  isRestElement,
+  isTemplateLiteral,
+  isVariableDeclarator,
+  toBindingIdentifierName
+} = _t;
+
+function getFunctionArity(node) {
+  const count = node.params.findIndex(param => isAssignmentPattern(param) || isRestElement(param));
+  return count === -1 ? node.params.length : count;
+}
+
+const buildPropertyMethodAssignmentWrapper = (0, _template.default)(`
+  (function (FUNCTION_KEY) {
+    function FUNCTION_ID() {
+      return FUNCTION_KEY.apply(this, arguments);
+    }
+
+    FUNCTION_ID.toString = function () {
+      return FUNCTION_KEY.toString();
+    }
+
+    return FUNCTION_ID;
+  })(FUNCTION)
+`);
+const buildGeneratorPropertyMethodAssignmentWrapper = (0, _template.default)(`
+  (function (FUNCTION_KEY) {
+    function* FUNCTION_ID() {
+      return yield* FUNCTION_KEY.apply(this, arguments);
+    }
+
+    FUNCTION_ID.toString = function () {
+      return FUNCTION_KEY.toString();
+    };
+
+    return FUNCTION_ID;
+  })(FUNCTION)
+`);
+const visitor = {
+  "ReferencedIdentifier|BindingIdentifier"(path, state) {
+    if (path.node.name !== state.name) return;
+    const localDeclar = path.scope.getBindingIdentifier(state.name);
+    if (localDeclar !== state.outerDeclar) return;
+    state.selfReference = true;
+    path.stop();
+  }
+
+};
+
+function getNameFromLiteralId(id) {
+  if (isNullLiteral(id)) {
+    return "null";
+  }
+
+  if (isRegExpLiteral(id)) {
+    return `_${id.pattern}_${id.flags}`;
+  }
+
+  if (isTemplateLiteral(id)) {
+    return id.quasis.map(quasi => quasi.value.raw).join("");
+  }
+
+  if (id.value !== undefined) {
+    return id.value + "";
+  }
+
+  return "";
+}
+
+function wrap(state, method, id, scope) {
+  if (state.selfReference) {
+    if (scope.hasBinding(id.name) && !scope.hasGlobal(id.name)) {
+      scope.rename(id.name);
+    } else {
+      if (!isFunction(method)) return;
+      let build = buildPropertyMethodAssignmentWrapper;
+
+      if (method.generator) {
+        build = buildGeneratorPropertyMethodAssignmentWrapper;
+      }
+
+      const template = build({
+        FUNCTION: method,
+        FUNCTION_ID: id,
+        FUNCTION_KEY: scope.generateUidIdentifier(id.name)
+      }).expression;
+      const params = template.callee.body.body[0].params;
+
+      for (let i = 0, len = getFunctionArity(method); i < len; i++) {
+        params.push(scope.generateUidIdentifier("x"));
+      }
+
+      return template;
+    }
+  }
+
+  method.id = id;
+  scope.getProgramParent().references[id.name] = true;
+}
+
+function visit(node, name, scope) {
+  const state = {
+    selfAssignment: false,
+    selfReference: false,
+    outerDeclar: scope.getBindingIdentifier(name),
+    references: [],
+    name: name
+  };
+  const binding = scope.getOwnBinding(name);
+
+  if (binding) {
+    if (binding.kind === "param") {
+      state.selfReference = true;
+    } else {}
+  } else if (state.outerDeclar || scope.hasGlobal(name)) {
+    scope.traverse(node, visitor, state);
+  }
+
+  return state;
+}
+
+function _default({
+  node,
+  parent,
+  scope,
+  id
+}, localBinding = false, supportUnicodeId = false) {
+  if (node.id) return;
+
+  if ((isObjectProperty(parent) || isObjectMethod(parent, {
+    kind: "method"
+  })) && (!parent.computed || isLiteral(parent.key))) {
+    id = parent.key;
+  } else if (isVariableDeclarator(parent)) {
+    id = parent.id;
+
+    if (isIdentifier(id) && !localBinding) {
+      const binding = scope.parent.getBinding(id.name);
+
+      if (binding && binding.constant && scope.getBinding(id.name) === binding) {
+        node.id = cloneNode(id);
+        node.id[NOT_LOCAL_BINDING] = true;
+        return;
+      }
+    }
+  } else if (isAssignmentExpression(parent, {
+    operator: "="
+  })) {
+    id = parent.left;
+  } else if (!id) {
+    return;
+  }
+
+  let name;
+
+  if (id && isLiteral(id)) {
+    name = getNameFromLiteralId(id);
+  } else if (id && isIdentifier(id)) {
+    name = id.name;
+  }
+
+  if (name === undefined) {
+    return;
+  }
+
+  if (!supportUnicodeId && isFunction(node) && /[\uD800-\uDFFF]/.test(name)) {
+    return;
+  }
+
+  name = toBindingIdentifierName(name);
+  id = identifier(name);
+  id[NOT_LOCAL_BINDING] = true;
+  const state = visit(node, name, scope);
+  return wrap(state, node, id, scope) || node;
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/helper-function-name/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@babel/helper-function-name",
+  "version": "7.17.9",
+  "description": "Helper function to change the property 'name' of every function",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-helper-function-name"
+  },
+  "homepage": "https://babel.dev/docs/en/next/babel-helper-function-name",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./lib/index.js",
+  "dependencies": {
+    "@babel/template": "^7.16.7",
+    "@babel/types": "^7.17.0"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "author": "The Babel Team (https://babel.dev/team)"
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/helper-hoist-variables/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/light-bolt11-decoder/examples/node_modules/@babel/helper-hoist-variables/README.md

@@ -0,0 +1,19 @@
+# @babel/helper-hoist-variables
+
+> Helper function to hoist variables
+
+See our website [@babel/helper-hoist-variables](https://babeljs.io/docs/en/babel-helper-hoist-variables) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save @babel/helper-hoist-variables
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/helper-hoist-variables
+```

node_modules/light-bolt11-decoder/examples/node_modules/@babel/helper-hoist-variables/lib/index.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = hoistVariables;
+
+var _t = require("@babel/types");
+
+const {
+  assignmentExpression,
+  expressionStatement,
+  identifier
+} = _t;
+const visitor = {
+  Scope(path, state) {
+    if (state.kind === "let") path.skip();
+  },
+
+  FunctionParent(path) {
+    path.skip();
+  },
+
+  VariableDeclaration(path, state) {
+    if (state.kind && path.node.kind !== state.kind) return;
+    const nodes = [];
+    const declarations = path.get("declarations");
+    let firstId;
+
+    for (const declar of declarations) {
+      firstId = declar.node.id;
+
+      if (declar.node.init) {
+        nodes.push(expressionStatement(assignmentExpression("=", declar.node.id, declar.node.init)));
+      }
+
+      for (const name of Object.keys(declar.getBindingIdentifiers())) {
+        state.emit(identifier(name), name, declar.node.init !== null);
+      }
+    }
+
+    if (path.parentPath.isFor({
+      left: path.node
+    })) {
+      path.replaceWith(firstId);
+    } else {
+      path.replaceWithMultiple(nodes);
+    }
+  }
+
+};
+
+function hoistVariables(path, emit, kind = "var") {
+  path.traverse(visitor, {
+    kind,
+    emit
+  });
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/helper-hoist-variables/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@babel/helper-hoist-variables",
+  "version": "7.16.7",
+  "description": "Helper function to hoist variables",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-helper-hoist-variables"
+  },
+  "homepage": "https://babel.dev/docs/en/next/babel-helper-hoist-variables",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./lib/index.js",
+  "dependencies": {
+    "@babel/types": "^7.16.7"
+  },
+  "TODO": "The @babel/traverse dependency is only needed for the NodePath TS type. We can consider exporting it from @babel/core.",
+  "devDependencies": {
+    "@babel/traverse": "^7.16.7"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "author": "The Babel Team (https://babel.dev/team)"
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/helper-module-imports/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/light-bolt11-decoder/examples/node_modules/@babel/helper-module-imports/README.md

@@ -0,0 +1,19 @@
+# @babel/helper-module-imports
+
+> Babel helper functions for inserting module loads
+
+See our website [@babel/helper-module-imports](https://babeljs.io/docs/en/babel-helper-module-imports) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save @babel/helper-module-imports
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/helper-module-imports
+```

node_modules/light-bolt11-decoder/examples/node_modules/@babel/helper-module-imports/lib/import-builder.js

@@ -0,0 +1,162 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _assert = require("assert");
+
+var _t = require("@babel/types");
+
+const {
+  callExpression,
+  cloneNode,
+  expressionStatement,
+  identifier,
+  importDeclaration,
+  importDefaultSpecifier,
+  importNamespaceSpecifier,
+  importSpecifier,
+  memberExpression,
+  stringLiteral,
+  variableDeclaration,
+  variableDeclarator
+} = _t;
+
+class ImportBuilder {
+  constructor(importedSource, scope, hub) {
+    this._statements = [];
+    this._resultName = null;
+    this._scope = null;
+    this._hub = null;
+    this._importedSource = void 0;
+    this._scope = scope;
+    this._hub = hub;
+    this._importedSource = importedSource;
+  }
+
+  done() {
+    return {
+      statements: this._statements,
+      resultName: this._resultName
+    };
+  }
+
+  import() {
+    this._statements.push(importDeclaration([], stringLiteral(this._importedSource)));
+
+    return this;
+  }
+
+  require() {
+    this._statements.push(expressionStatement(callExpression(identifier("require"), [stringLiteral(this._importedSource)])));
+
+    return this;
+  }
+
+  namespace(name = "namespace") {
+    const local = this._scope.generateUidIdentifier(name);
+
+    const statement = this._statements[this._statements.length - 1];
+
+    _assert(statement.type === "ImportDeclaration");
+
+    _assert(statement.specifiers.length === 0);
+
+    statement.specifiers = [importNamespaceSpecifier(local)];
+    this._resultName = cloneNode(local);
+    return this;
+  }
+
+  default(name) {
+    name = this._scope.generateUidIdentifier(name);
+    const statement = this._statements[this._statements.length - 1];
+
+    _assert(statement.type === "ImportDeclaration");
+
+    _assert(statement.specifiers.length === 0);
+
+    statement.specifiers = [importDefaultSpecifier(name)];
+    this._resultName = cloneNode(name);
+    return this;
+  }
+
+  named(name, importName) {
+    if (importName === "default") return this.default(name);
+    name = this._scope.generateUidIdentifier(name);
+    const statement = this._statements[this._statements.length - 1];
+
+    _assert(statement.type === "ImportDeclaration");
+
+    _assert(statement.specifiers.length === 0);
+
+    statement.specifiers = [importSpecifier(name, identifier(importName))];
+    this._resultName = cloneNode(name);
+    return this;
+  }
+
+  var(name) {
+    name = this._scope.generateUidIdentifier(name);
+    let statement = this._statements[this._statements.length - 1];
+
+    if (statement.type !== "ExpressionStatement") {
+      _assert(this._resultName);
+
+      statement = expressionStatement(this._resultName);
+
+      this._statements.push(statement);
+    }
+
+    this._statements[this._statements.length - 1] = variableDeclaration("var", [variableDeclarator(name, statement.expression)]);
+    this._resultName = cloneNode(name);
+    return this;
+  }
+
+  defaultInterop() {
+    return this._interop(this._hub.addHelper("interopRequireDefault"));
+  }
+
+  wildcardInterop() {
+    return this._interop(this._hub.addHelper("interopRequireWildcard"));
+  }
+
+  _interop(callee) {
+    const statement = this._statements[this._statements.length - 1];
+
+    if (statement.type === "ExpressionStatement") {
+      statement.expression = callExpression(callee, [statement.expression]);
+    } else if (statement.type === "VariableDeclaration") {
+      _assert(statement.declarations.length === 1);
+
+      statement.declarations[0].init = callExpression(callee, [statement.declarations[0].init]);
+    } else {
+      _assert.fail("Unexpected type.");
+    }
+
+    return this;
+  }
+
+  prop(name) {
+    const statement = this._statements[this._statements.length - 1];
+
+    if (statement.type === "ExpressionStatement") {
+      statement.expression = memberExpression(statement.expression, identifier(name));
+    } else if (statement.type === "VariableDeclaration") {
+      _assert(statement.declarations.length === 1);
+
+      statement.declarations[0].init = memberExpression(statement.declarations[0].init, identifier(name));
+    } else {
+      _assert.fail("Unexpected type:" + statement.type);
+    }
+
+    return this;
+  }
+
+  read(name) {
+    this._resultName = memberExpression(this._resultName, identifier(name));
+  }
+
+}
+
+exports.default = ImportBuilder;

node_modules/light-bolt11-decoder/examples/node_modules/@babel/helper-module-imports/lib/import-injector.js

@@ -0,0 +1,290 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _assert = require("assert");
+
+var _t = require("@babel/types");
+
+var _importBuilder = require("./import-builder");
+
+var _isModule = require("./is-module");
+
+const {
+  numericLiteral,
+  sequenceExpression
+} = _t;
+
+class ImportInjector {
+  constructor(path, importedSource, opts) {
+    this._defaultOpts = {
+      importedSource: null,
+      importedType: "commonjs",
+      importedInterop: "babel",
+      importingInterop: "babel",
+      ensureLiveReference: false,
+      ensureNoContext: false,
+      importPosition: "before"
+    };
+    const programPath = path.find(p => p.isProgram());
+    this._programPath = programPath;
+    this._programScope = programPath.scope;
+    this._hub = programPath.hub;
+    this._defaultOpts = this._applyDefaults(importedSource, opts, true);
+  }
+
+  addDefault(importedSourceIn, opts) {
+    return this.addNamed("default", importedSourceIn, opts);
+  }
+
+  addNamed(importName, importedSourceIn, opts) {
+    _assert(typeof importName === "string");
+
+    return this._generateImport(this._applyDefaults(importedSourceIn, opts), importName);
+  }
+
+  addNamespace(importedSourceIn, opts) {
+    return this._generateImport(this._applyDefaults(importedSourceIn, opts), null);
+  }
+
+  addSideEffect(importedSourceIn, opts) {
+    return this._generateImport(this._applyDefaults(importedSourceIn, opts), false);
+  }
+
+  _applyDefaults(importedSource, opts, isInit = false) {
+    const optsList = [];
+
+    if (typeof importedSource === "string") {
+      optsList.push({
+        importedSource
+      });
+      optsList.push(opts);
+    } else {
+      _assert(!opts, "Unexpected secondary arguments.");
+
+      optsList.push(importedSource);
+    }
+
+    const newOpts = Object.assign({}, this._defaultOpts);
+
+    for (const opts of optsList) {
+      if (!opts) continue;
+      Object.keys(newOpts).forEach(key => {
+        if (opts[key] !== undefined) newOpts[key] = opts[key];
+      });
+
+      if (!isInit) {
+        if (opts.nameHint !== undefined) newOpts.nameHint = opts.nameHint;
+        if (opts.blockHoist !== undefined) newOpts.blockHoist = opts.blockHoist;
+      }
+    }
+
+    return newOpts;
+  }
+
+  _generateImport(opts, importName) {
+    const isDefault = importName === "default";
+    const isNamed = !!importName && !isDefault;
+    const isNamespace = importName === null;
+    const {
+      importedSource,
+      importedType,
+      importedInterop,
+      importingInterop,
+      ensureLiveReference,
+      ensureNoContext,
+      nameHint,
+      importPosition,
+      blockHoist
+    } = opts;
+    let name = nameHint || importName;
+    const isMod = (0, _isModule.default)(this._programPath);
+    const isModuleForNode = isMod && importingInterop === "node";
+    const isModuleForBabel = isMod && importingInterop === "babel";
+
+    if (importPosition === "after" && !isMod) {
+      throw new Error(`"importPosition": "after" is only supported in modules`);
+    }
+
+    const builder = new _importBuilder.default(importedSource, this._programScope, this._hub);
+
+    if (importedType === "es6") {
+      if (!isModuleForNode && !isModuleForBabel) {
+        throw new Error("Cannot import an ES6 module from CommonJS");
+      }
+
+      builder.import();
+
+      if (isNamespace) {
+        builder.namespace(nameHint || importedSource);
+      } else if (isDefault || isNamed) {
+        builder.named(name, importName);
+      }
+    } else if (importedType !== "commonjs") {
+      throw new Error(`Unexpected interopType "${importedType}"`);
+    } else if (importedInterop === "babel") {
+      if (isModuleForNode) {
+        name = name !== "default" ? name : importedSource;
+        const es6Default = `${importedSource}$es6Default`;
+        builder.import();
+
+        if (isNamespace) {
+          builder.default(es6Default).var(name || importedSource).wildcardInterop();
+        } else if (isDefault) {
+          if (ensureLiveReference) {
+            builder.default(es6Default).var(name || importedSource).defaultInterop().read("default");
+          } else {
+            builder.default(es6Default).var(name).defaultInterop().prop(importName);
+          }
+        } else if (isNamed) {
+          builder.default(es6Default).read(importName);
+        }
+      } else if (isModuleForBabel) {
+        builder.import();
+
+        if (isNamespace) {
+          builder.namespace(name || importedSource);
+        } else if (isDefault || isNamed) {
+          builder.named(name, importName);
+        }
+      } else {
+        builder.require();
+
+        if (isNamespace) {
+          builder.var(name || importedSource).wildcardInterop();
+        } else if ((isDefault || isNamed) && ensureLiveReference) {
+          if (isDefault) {
+            name = name !== "default" ? name : importedSource;
+            builder.var(name).read(importName);
+            builder.defaultInterop();
+          } else {
+            builder.var(importedSource).read(importName);
+          }
+        } else if (isDefault) {
+          builder.var(name).defaultInterop().prop(importName);
+        } else if (isNamed) {
+          builder.var(name).prop(importName);
+        }
+      }
+    } else if (importedInterop === "compiled") {
+      if (isModuleForNode) {
+        builder.import();
+
+        if (isNamespace) {
+          builder.default(name || importedSource);
+        } else if (isDefault || isNamed) {
+          builder.default(importedSource).read(name);
+        }
+      } else if (isModuleForBabel) {
+        builder.import();
+
+        if (isNamespace) {
+          builder.namespace(name || importedSource);
+        } else if (isDefault || isNamed) {
+          builder.named(name, importName);
+        }
+      } else {
+        builder.require();
+
+        if (isNamespace) {
+          builder.var(name || importedSource);
+        } else if (isDefault || isNamed) {
+          if (ensureLiveReference) {
+            builder.var(importedSource).read(name);
+          } else {
+            builder.prop(importName).var(name);
+          }
+        }
+      }
+    } else if (importedInterop === "uncompiled") {
+      if (isDefault && ensureLiveReference) {
+        throw new Error("No live reference for commonjs default");
+      }
+
+      if (isModuleForNode) {
+        builder.import();
+
+        if (isNamespace) {
+          builder.default(name || importedSource);
+        } else if (isDefault) {
+          builder.default(name);
+        } else if (isNamed) {
+          builder.default(importedSource).read(name);
+        }
+      } else if (isModuleForBabel) {
+        builder.import();
+
+        if (isNamespace) {
+          builder.default(name || importedSource);
+        } else if (isDefault) {
+          builder.default(name);
+        } else if (isNamed) {
+          builder.named(name, importName);
+        }
+      } else {
+        builder.require();
+
+        if (isNamespace) {
+          builder.var(name || importedSource);
+        } else if (isDefault) {
+          builder.var(name);
+        } else if (isNamed) {
+          if (ensureLiveReference) {
+            builder.var(importedSource).read(name);
+          } else {
+            builder.var(name).prop(importName);
+          }
+        }
+      }
+    } else {
+      throw new Error(`Unknown importedInterop "${importedInterop}".`);
+    }
+
+    const {
+      statements,
+      resultName
+    } = builder.done();
+
+    this._insertStatements(statements, importPosition, blockHoist);
+
+    if ((isDefault || isNamed) && ensureNoContext && resultName.type !== "Identifier") {
+      return sequenceExpression([numericLiteral(0), resultName]);
+    }
+
+    return resultName;
+  }
+
+  _insertStatements(statements, importPosition = "before", blockHoist = 3) {
+    const body = this._programPath.get("body");
+
+    if (importPosition === "after") {
+      for (let i = body.length - 1; i >= 0; i--) {
+        if (body[i].isImportDeclaration()) {
+          body[i].insertAfter(statements);
+          return;
+        }
+      }
+    } else {
+      statements.forEach(node => {
+        node._blockHoist = blockHoist;
+      });
+      const targetPath = body.find(p => {
+        const val = p.node._blockHoist;
+        return Number.isFinite(val) && val < 4;
+      });
+
+      if (targetPath) {
+        targetPath.insertBefore(statements);
+        return;
+      }
+    }
+
+    this._programPath.unshiftContainer("body", statements);
+  }
+
+}
+
+exports.default = ImportInjector;

node_modules/light-bolt11-decoder/examples/node_modules/@babel/helper-module-imports/lib/index.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "ImportInjector", {
+  enumerable: true,
+  get: function () {
+    return _importInjector.default;
+  }
+});
+exports.addDefault = addDefault;
+exports.addNamed = addNamed;
+exports.addNamespace = addNamespace;
+exports.addSideEffect = addSideEffect;
+Object.defineProperty(exports, "isModule", {
+  enumerable: true,
+  get: function () {
+    return _isModule.default;
+  }
+});
+
+var _importInjector = require("./import-injector");
+
+var _isModule = require("./is-module");
+
+function addDefault(path, importedSource, opts) {
+  return new _importInjector.default(path).addDefault(importedSource, opts);
+}
+
+function addNamed(path, name, importedSource, opts) {
+  return new _importInjector.default(path).addNamed(name, importedSource, opts);
+}
+
+function addNamespace(path, importedSource, opts) {
+  return new _importInjector.default(path).addNamespace(importedSource, opts);
+}
+
+function addSideEffect(path, importedSource, opts) {
+  return new _importInjector.default(path).addSideEffect(importedSource, opts);
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/helper-module-imports/lib/is-module.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isModule;
+
+function isModule(path) {
+  const {
+    sourceType
+  } = path.node;
+
+  if (sourceType !== "module" && sourceType !== "script") {
+    throw path.buildCodeFrameError(`Unknown sourceType "${sourceType}", cannot transform.`);
+  }
+
+  return path.node.sourceType === "module";
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/helper-module-imports/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@babel/helper-module-imports",
+  "version": "7.16.7",
+  "description": "Babel helper functions for inserting module loads",
+  "author": "The Babel Team (https://babel.dev/team)",
+  "homepage": "https://babel.dev/docs/en/next/babel-helper-module-imports",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-helper-module-imports"
+  },
+  "main": "./lib/index.js",
+  "dependencies": {
+    "@babel/types": "^7.16.7"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.16.7",
+    "@babel/traverse": "^7.16.7"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  }
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/helper-split-export-declaration/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/light-bolt11-decoder/examples/node_modules/@babel/helper-split-export-declaration/README.md

@@ -0,0 +1,19 @@
+# @babel/helper-split-export-declaration
+
+> 
+
+See our website [@babel/helper-split-export-declaration](https://babeljs.io/docs/en/babel-helper-split-export-declaration) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save @babel/helper-split-export-declaration
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/helper-split-export-declaration
+```

node_modules/light-bolt11-decoder/examples/node_modules/@babel/helper-split-export-declaration/lib/index.js

@@ -0,0 +1,67 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = splitExportDeclaration;
+
+var _t = require("@babel/types");
+
+const {
+  cloneNode,
+  exportNamedDeclaration,
+  exportSpecifier,
+  identifier,
+  variableDeclaration,
+  variableDeclarator
+} = _t;
+
+function splitExportDeclaration(exportDeclaration) {
+  if (!exportDeclaration.isExportDeclaration()) {
+    throw new Error("Only export declarations can be split.");
+  }
+
+  const isDefault = exportDeclaration.isExportDefaultDeclaration();
+  const declaration = exportDeclaration.get("declaration");
+  const isClassDeclaration = declaration.isClassDeclaration();
+
+  if (isDefault) {
+    const standaloneDeclaration = declaration.isFunctionDeclaration() || isClassDeclaration;
+    const scope = declaration.isScope() ? declaration.scope.parent : declaration.scope;
+    let id = declaration.node.id;
+    let needBindingRegistration = false;
+
+    if (!id) {
+      needBindingRegistration = true;
+      id = scope.generateUidIdentifier("default");
+
+      if (standaloneDeclaration || declaration.isFunctionExpression() || declaration.isClassExpression()) {
+        declaration.node.id = cloneNode(id);
+      }
+    }
+
+    const updatedDeclaration = standaloneDeclaration ? declaration : variableDeclaration("var", [variableDeclarator(cloneNode(id), declaration.node)]);
+    const updatedExportDeclaration = exportNamedDeclaration(null, [exportSpecifier(cloneNode(id), identifier("default"))]);
+    exportDeclaration.insertAfter(updatedExportDeclaration);
+    exportDeclaration.replaceWith(updatedDeclaration);
+
+    if (needBindingRegistration) {
+      scope.registerDeclaration(exportDeclaration);
+    }
+
+    return exportDeclaration;
+  }
+
+  if (exportDeclaration.get("specifiers").length > 0) {
+    throw new Error("It doesn't make sense to split exported specifiers.");
+  }
+
+  const bindingIdentifiers = declaration.getOuterBindingIdentifiers();
+  const specifiers = Object.keys(bindingIdentifiers).map(name => {
+    return exportSpecifier(identifier(name), identifier(name));
+  });
+  const aliasDeclar = exportNamedDeclaration(null, specifiers);
+  exportDeclaration.insertAfter(aliasDeclar);
+  exportDeclaration.replaceWith(declaration.node);
+  return exportDeclaration;
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/helper-split-export-declaration/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@babel/helper-split-export-declaration",
+  "version": "7.16.7",
+  "description": "",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-helper-split-export-declaration"
+  },
+  "homepage": "https://babel.dev/docs/en/next/babel-helper-split-export-declaration",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./lib/index.js",
+  "dependencies": {
+    "@babel/types": "^7.16.7"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "author": "The Babel Team (https://babel.dev/team)"
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/helper-validator-identifier/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/light-bolt11-decoder/examples/node_modules/@babel/helper-validator-identifier/README.md

@@ -0,0 +1,19 @@
+# @babel/helper-validator-identifier
+
+> Validate identifier/keywords name
+
+See our website [@babel/helper-validator-identifier](https://babeljs.io/docs/en/babel-helper-validator-identifier) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save @babel/helper-validator-identifier
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/helper-validator-identifier
+```

node_modules/light-bolt11-decoder/examples/node_modules/@babel/helper-validator-identifier/lib/identifier.js

@@ -0,0 +1,84 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isIdentifierChar = isIdentifierChar;
+exports.isIdentifierName = isIdentifierName;
+exports.isIdentifierStart = isIdentifierStart;
+let nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0559\u0560-\u0588\u05d0-\u05ea\u05ef-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u0860-\u086a\u0870-\u0887\u0889-\u088e\u08a0-\u08c9\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u09fc\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0af9\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c58-\u0c5a\u0c5d\u0c60\u0c61\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cdd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d04-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d54-\u0d56\u0d5f-\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u1711\u171f-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1878\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4c\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c88\u1c90-\u1cba\u1cbd-\u1cbf\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5\u1cf6\u1cfa\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309b-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31bf\u31f0-\u31ff\u3400-\u4dbf\u4e00-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua69d\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7ca\ua7d0\ua7d1\ua7d3\ua7d5-\ua7d9\ua7f2-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd\ua8fe\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\ua9e0-\ua9e4\ua9e6-\ua9ef\ua9fa-\ua9fe\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa7e-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab69\uab70-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
+let nonASCIIidentifierChars = "\u200c\u200d\xb7\u0300-\u036f\u0387\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u0669\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7\u06e8\u06ea-\u06ed\u06f0-\u06f9\u0711\u0730-\u074a\u07a6-\u07b0\u07c0-\u07c9\u07eb-\u07f3\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u0898-\u089f\u08ca-\u08e1\u08e3-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09cb-\u09cd\u09d7\u09e2\u09e3\u09e6-\u09ef\u09fe\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2\u0ae3\u0ae6-\u0aef\u0afa-\u0aff\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b62\u0b63\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c00-\u0c04\u0c3c\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0c66-\u0c6f\u0c81-\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0ce6-\u0cef\u0d00-\u0d03\u0d3b\u0d3c\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0d62\u0d63\u0d66-\u0d6f\u0d81-\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2\u0df3\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0e50-\u0e59\u0eb1\u0eb4-\u0ebc\u0ec8-\u0ecd\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e\u0f3f\u0f71-\u0f84\u0f86\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102b-\u103e\u1040-\u1049\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u1369-\u1371\u1712-\u1715\u1732-\u1734\u1752\u1753\u1772\u1773\u17b4-\u17d3\u17dd\u17e0-\u17e9\u180b-\u180d\u180f-\u1819\u18a9\u1920-\u192b\u1930-\u193b\u1946-\u194f\u19d0-\u19da\u1a17-\u1a1b\u1a55-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1ab0-\u1abd\u1abf-\u1ace\u1b00-\u1b04\u1b34-\u1b44\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bf3\u1c24-\u1c37\u1c40-\u1c49\u1c50-\u1c59\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1dc0-\u1dff\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099\u309a\ua620-\ua629\ua66f\ua674-\ua67d\ua69e\ua69f\ua6f0\ua6f1\ua802\ua806\ua80b\ua823-\ua827\ua82c\ua880\ua881\ua8b4-\ua8c5\ua8d0-\ua8d9\ua8e0-\ua8f1\ua8ff-\ua909\ua926-\ua92d\ua947-\ua953\ua980-\ua983\ua9b3-\ua9c0\ua9d0-\ua9d9\ua9e5\ua9f0-\ua9f9\uaa29-\uaa36\uaa43\uaa4c\uaa4d\uaa50-\uaa59\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uaaeb-\uaaef\uaaf5\uaaf6\uabe3-\uabea\uabec\uabed\uabf0-\uabf9\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f";
+const nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
+const nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
+nonASCIIidentifierStartChars = nonASCIIidentifierChars = null;
+const astralIdentifierStartCodes = [0, 11, 2, 25, 2, 18, 2, 1, 2, 14, 3, 13, 35, 122, 70, 52, 268, 28, 4, 48, 48, 31, 14, 29, 6, 37, 11, 29, 3, 35, 5, 7, 2, 4, 43, 157, 19, 35, 5, 35, 5, 39, 9, 51, 13, 10, 2, 14, 2, 6, 2, 1, 2, 10, 2, 14, 2, 6, 2, 1, 68, 310, 10, 21, 11, 7, 25, 5, 2, 41, 2, 8, 70, 5, 3, 0, 2, 43, 2, 1, 4, 0, 3, 22, 11, 22, 10, 30, 66, 18, 2, 1, 11, 21, 11, 25, 71, 55, 7, 1, 65, 0, 16, 3, 2, 2, 2, 28, 43, 28, 4, 28, 36, 7, 2, 27, 28, 53, 11, 21, 11, 18, 14, 17, 111, 72, 56, 50, 14, 50, 14, 35, 349, 41, 7, 1, 79, 28, 11, 0, 9, 21, 43, 17, 47, 20, 28, 22, 13, 52, 58, 1, 3, 0, 14, 44, 33, 24, 27, 35, 30, 0, 3, 0, 9, 34, 4, 0, 13, 47, 15, 3, 22, 0, 2, 0, 36, 17, 2, 24, 85, 6, 2, 0, 2, 3, 2, 14, 2, 9, 8, 46, 39, 7, 3, 1, 3, 21, 2, 6, 2, 1, 2, 4, 4, 0, 19, 0, 13, 4, 159, 52, 19, 3, 21, 2, 31, 47, 21, 1, 2, 0, 185, 46, 42, 3, 37, 47, 21, 0, 60, 42, 14, 0, 72, 26, 38, 6, 186, 43, 117, 63, 32, 7, 3, 0, 3, 7, 2, 1, 2, 23, 16, 0, 2, 0, 95, 7, 3, 38, 17, 0, 2, 0, 29, 0, 11, 39, 8, 0, 22, 0, 12, 45, 20, 0, 19, 72, 264, 8, 2, 36, 18, 0, 50, 29, 113, 6, 2, 1, 2, 37, 22, 0, 26, 5, 2, 1, 2, 31, 15, 0, 328, 18, 190, 0, 80, 921, 103, 110, 18, 195, 2637, 96, 16, 1070, 4050, 582, 8634, 568, 8, 30, 18, 78, 18, 29, 19, 47, 17, 3, 32, 20, 6, 18, 689, 63, 129, 74, 6, 0, 67, 12, 65, 1, 2, 0, 29, 6135, 9, 1237, 43, 8, 8936, 3, 2, 6, 2, 1, 2, 290, 46, 2, 18, 3, 9, 395, 2309, 106, 6, 12, 4, 8, 8, 9, 5991, 84, 2, 70, 2, 1, 3, 0, 3, 1, 3, 3, 2, 11, 2, 0, 2, 6, 2, 64, 2, 3, 3, 7, 2, 6, 2, 27, 2, 3, 2, 4, 2, 0, 4, 6, 2, 339, 3, 24, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 7, 1845, 30, 482, 44, 11, 6, 17, 0, 322, 29, 19, 43, 1269, 6, 2, 3, 2, 1, 2, 14, 2, 196, 60, 67, 8, 0, 1205, 3, 2, 26, 2, 1, 2, 0, 3, 0, 2, 9, 2, 3, 2, 0, 2, 0, 7, 0, 5, 0, 2, 0, 2, 0, 2, 2, 2, 1, 2, 0, 3, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 1, 2, 0, 3, 3, 2, 6, 2, 3, 2, 3, 2, 0, 2, 9, 2, 16, 6, 2, 2, 4, 2, 16, 4421, 42719, 33, 4152, 8, 221, 3, 5761, 15, 7472, 3104, 541, 1507, 4938];
+const astralIdentifierCodes = [509, 0, 227, 0, 150, 4, 294, 9, 1368, 2, 2, 1, 6, 3, 41, 2, 5, 0, 166, 1, 574, 3, 9, 9, 370, 1, 154, 10, 50, 3, 123, 2, 54, 14, 32, 10, 3, 1, 11, 3, 46, 10, 8, 0, 46, 9, 7, 2, 37, 13, 2, 9, 6, 1, 45, 0, 13, 2, 49, 13, 9, 3, 2, 11, 83, 11, 7, 0, 161, 11, 6, 9, 7, 3, 56, 1, 2, 6, 3, 1, 3, 2, 10, 0, 11, 1, 3, 6, 4, 4, 193, 17, 10, 9, 5, 0, 82, 19, 13, 9, 214, 6, 3, 8, 28, 1, 83, 16, 16, 9, 82, 12, 9, 9, 84, 14, 5, 9, 243, 14, 166, 9, 71, 5, 2, 1, 3, 3, 2, 0, 2, 1, 13, 9, 120, 6, 3, 6, 4, 0, 29, 9, 41, 6, 2, 3, 9, 0, 10, 10, 47, 15, 406, 7, 2, 7, 17, 9, 57, 21, 2, 13, 123, 5, 4, 0, 2, 1, 2, 6, 2, 0, 9, 9, 49, 4, 2, 1, 2, 4, 9, 9, 330, 3, 19306, 9, 87, 9, 39, 4, 60, 6, 26, 9, 1014, 0, 2, 54, 8, 3, 82, 0, 12, 1, 19628, 1, 4706, 45, 3, 22, 543, 4, 4, 5, 9, 7, 3, 6, 31, 3, 149, 2, 1418, 49, 513, 54, 5, 49, 9, 0, 15, 0, 23, 4, 2, 14, 1361, 6, 2, 16, 3, 6, 2, 1, 2, 4, 262, 6, 10, 9, 357, 0, 62, 13, 1495, 6, 110, 6, 6, 9, 4759, 9, 787719, 239];
+
+function isInAstralSet(code, set) {
+  let pos = 0x10000;
+
+  for (let i = 0, length = set.length; i < length; i += 2) {
+    pos += set[i];
+    if (pos > code) return false;
+    pos += set[i + 1];
+    if (pos >= code) return true;
+  }
+
+  return false;
+}
+
+function isIdentifierStart(code) {
+  if (code < 65) return code === 36;
+  if (code <= 90) return true;
+  if (code < 97) return code === 95;
+  if (code <= 122) return true;
+
+  if (code <= 0xffff) {
+    return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));
+  }
+
+  return isInAstralSet(code, astralIdentifierStartCodes);
+}
+
+function isIdentifierChar(code) {
+  if (code < 48) return code === 36;
+  if (code < 58) return true;
+  if (code < 65) return false;
+  if (code <= 90) return true;
+  if (code < 97) return code === 95;
+  if (code <= 122) return true;
+
+  if (code <= 0xffff) {
+    return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
+  }
+
+  return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes);
+}
+
+function isIdentifierName(name) {
+  let isFirst = true;
+
+  for (let i = 0; i < name.length; i++) {
+    let cp = name.charCodeAt(i);
+
+    if ((cp & 0xfc00) === 0xd800 && i + 1 < name.length) {
+      const trail = name.charCodeAt(++i);
+
+      if ((trail & 0xfc00) === 0xdc00) {
+        cp = 0x10000 + ((cp & 0x3ff) << 10) + (trail & 0x3ff);
+      }
+    }
+
+    if (isFirst) {
+      isFirst = false;
+
+      if (!isIdentifierStart(cp)) {
+        return false;
+      }
+    } else if (!isIdentifierChar(cp)) {
+      return false;
+    }
+  }
+
+  return !isFirst;
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/helper-validator-identifier/lib/index.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "isIdentifierChar", {
+  enumerable: true,
+  get: function () {
+    return _identifier.isIdentifierChar;
+  }
+});
+Object.defineProperty(exports, "isIdentifierName", {
+  enumerable: true,
+  get: function () {
+    return _identifier.isIdentifierName;
+  }
+});
+Object.defineProperty(exports, "isIdentifierStart", {
+  enumerable: true,
+  get: function () {
+    return _identifier.isIdentifierStart;
+  }
+});
+Object.defineProperty(exports, "isKeyword", {
+  enumerable: true,
+  get: function () {
+    return _keyword.isKeyword;
+  }
+});
+Object.defineProperty(exports, "isReservedWord", {
+  enumerable: true,
+  get: function () {
+    return _keyword.isReservedWord;
+  }
+});
+Object.defineProperty(exports, "isStrictBindOnlyReservedWord", {
+  enumerable: true,
+  get: function () {
+    return _keyword.isStrictBindOnlyReservedWord;
+  }
+});
+Object.defineProperty(exports, "isStrictBindReservedWord", {
+  enumerable: true,
+  get: function () {
+    return _keyword.isStrictBindReservedWord;
+  }
+});
+Object.defineProperty(exports, "isStrictReservedWord", {
+  enumerable: true,
+  get: function () {
+    return _keyword.isStrictReservedWord;
+  }
+});
+
+var _identifier = require("./identifier");
+
+var _keyword = require("./keyword");

node_modules/light-bolt11-decoder/examples/node_modules/@babel/helper-validator-identifier/lib/keyword.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isKeyword = isKeyword;
+exports.isReservedWord = isReservedWord;
+exports.isStrictBindOnlyReservedWord = isStrictBindOnlyReservedWord;
+exports.isStrictBindReservedWord = isStrictBindReservedWord;
+exports.isStrictReservedWord = isStrictReservedWord;
+const reservedWords = {
+  keyword: ["break", "case", "catch", "continue", "debugger", "default", "do", "else", "finally", "for", "function", "if", "return", "switch", "throw", "try", "var", "const", "while", "with", "new", "this", "super", "class", "extends", "export", "import", "null", "true", "false", "in", "instanceof", "typeof", "void", "delete"],
+  strict: ["implements", "interface", "let", "package", "private", "protected", "public", "static", "yield"],
+  strictBind: ["eval", "arguments"]
+};
+const keywords = new Set(reservedWords.keyword);
+const reservedWordsStrictSet = new Set(reservedWords.strict);
+const reservedWordsStrictBindSet = new Set(reservedWords.strictBind);
+
+function isReservedWord(word, inModule) {
+  return inModule && word === "await" || word === "enum";
+}
+
+function isStrictReservedWord(word, inModule) {
+  return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word);
+}
+
+function isStrictBindOnlyReservedWord(word) {
+  return reservedWordsStrictBindSet.has(word);
+}
+
+function isStrictBindReservedWord(word, inModule) {
+  return isStrictReservedWord(word, inModule) || isStrictBindOnlyReservedWord(word);
+}
+
+function isKeyword(word) {
+  return keywords.has(word);
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/helper-validator-identifier/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@babel/helper-validator-identifier",
+  "version": "7.16.7",
+  "description": "Validate identifier/keywords name",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-helper-validator-identifier"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./package.json": "./package.json"
+  },
+  "devDependencies": {
+    "@unicode/unicode-14.0.0": "^1.2.1",
+    "charcodes": "^0.2.0"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "author": "The Babel Team (https://babel.dev/team)"
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/helper-validator-identifier/scripts/generate-identifier-regex.js

@@ -0,0 +1,75 @@
+"use strict";
+
+// Always use the latest available version of Unicode!
+// https://tc39.github.io/ecma262/#sec-conformance
+const version = "14.0.0";
+
+const start = require("@unicode/unicode-" +
+  version +
+  "/Binary_Property/ID_Start/code-points.js").filter(function (ch) {
+  return ch > 0x7f;
+});
+let last = -1;
+const cont = [0x200c, 0x200d].concat(
+  require("@unicode/unicode-" +
+    version +
+    "/Binary_Property/ID_Continue/code-points.js").filter(function (ch) {
+    return ch > 0x7f && search(start, ch, last + 1) == -1;
+  })
+);
+
+function search(arr, ch, starting) {
+  for (let i = starting; arr[i] <= ch && i < arr.length; last = i++) {
+    if (arr[i] === ch) return i;
+  }
+  return -1;
+}
+
+function pad(str, width) {
+  while (str.length < width) str = "0" + str;
+  return str;
+}
+
+function esc(code) {
+  const hex = code.toString(16);
+  if (hex.length <= 2) return "\\x" + pad(hex, 2);
+  else return "\\u" + pad(hex, 4);
+}
+
+function generate(chars) {
+  const astral = [];
+  let re = "";
+  for (let i = 0, at = 0x10000; i < chars.length; i++) {
+    const from = chars[i];
+    let to = from;
+    while (i < chars.length - 1 && chars[i + 1] == to + 1) {
+      i++;
+      to++;
+    }
+    if (to <= 0xffff) {
+      if (from == to) re += esc(from);
+      else if (from + 1 == to) re += esc(from) + esc(to);
+      else re += esc(from) + "-" + esc(to);
+    } else {
+      astral.push(from - at, to - from);
+      at = to;
+    }
+  }
+  return { nonASCII: re, astral: astral };
+}
+
+const startData = generate(start);
+const contData = generate(cont);
+
+console.log("/* prettier-ignore */");
+console.log('let nonASCIIidentifierStartChars = "' + startData.nonASCII + '";');
+console.log("/* prettier-ignore */");
+console.log('let nonASCIIidentifierChars = "' + contData.nonASCII + '";');
+console.log("/* prettier-ignore */");
+console.log(
+  "const astralIdentifierStartCodes = " + JSON.stringify(startData.astral) + ";"
+);
+console.log("/* prettier-ignore */");
+console.log(
+  "const astralIdentifierCodes = " + JSON.stringify(contData.astral) + ";"
+);

node_modules/light-bolt11-decoder/examples/node_modules/@babel/highlight/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/light-bolt11-decoder/examples/node_modules/@babel/highlight/README.md

@@ -0,0 +1,19 @@
+# @babel/highlight
+
+> Syntax highlight JavaScript strings for output in terminals.
+
+See our website [@babel/highlight](https://babeljs.io/docs/en/babel-highlight) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/highlight
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/highlight --dev
+```

node_modules/light-bolt11-decoder/examples/node_modules/@babel/highlight/lib/index.js

@@ -0,0 +1,116 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = highlight;
+exports.getChalk = getChalk;
+exports.shouldHighlight = shouldHighlight;
+
+var _jsTokens = require("js-tokens");
+
+var _helperValidatorIdentifier = require("@babel/helper-validator-identifier");
+
+var _chalk = require("chalk");
+
+const sometimesKeywords = new Set(["as", "async", "from", "get", "of", "set"]);
+
+function getDefs(chalk) {
+  return {
+    keyword: chalk.cyan,
+    capitalized: chalk.yellow,
+    jsxIdentifier: chalk.yellow,
+    punctuator: chalk.yellow,
+    number: chalk.magenta,
+    string: chalk.green,
+    regex: chalk.magenta,
+    comment: chalk.grey,
+    invalid: chalk.white.bgRed.bold
+  };
+}
+
+const NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
+const BRACKET = /^[()[\]{}]$/;
+let tokenize;
+{
+  const JSX_TAG = /^[a-z][\w-]*$/i;
+
+  const getTokenType = function (token, offset, text) {
+    if (token.type === "name") {
+      if ((0, _helperValidatorIdentifier.isKeyword)(token.value) || (0, _helperValidatorIdentifier.isStrictReservedWord)(token.value, true) || sometimesKeywords.has(token.value)) {
+        return "keyword";
+      }
+
+      if (JSX_TAG.test(token.value) && (text[offset - 1] === "<" || text.slice(offset - 2, offset) == "</")) {
+        return "jsxIdentifier";
+      }
+
+      if (token.value[0] !== token.value[0].toLowerCase()) {
+        return "capitalized";
+      }
+    }
+
+    if (token.type === "punctuator" && BRACKET.test(token.value)) {
+      return "bracket";
+    }
+
+    if (token.type === "invalid" && (token.value === "@" || token.value === "#")) {
+      return "punctuator";
+    }
+
+    return token.type;
+  };
+
+  tokenize = function* (text) {
+    let match;
+
+    while (match = _jsTokens.default.exec(text)) {
+      const token = _jsTokens.matchToToken(match);
+
+      yield {
+        type: getTokenType(token, match.index, text),
+        value: token.value
+      };
+    }
+  };
+}
+
+function highlightTokens(defs, text) {
+  let highlighted = "";
+
+  for (const {
+    type,
+    value
+  } of tokenize(text)) {
+    const colorize = defs[type];
+
+    if (colorize) {
+      highlighted += value.split(NEWLINE).map(str => colorize(str)).join("\n");
+    } else {
+      highlighted += value;
+    }
+  }
+
+  return highlighted;
+}
+
+function shouldHighlight(options) {
+  return !!_chalk.supportsColor || options.forceColor;
+}
+
+function getChalk(options) {
+  return options.forceColor ? new _chalk.constructor({
+    enabled: true,
+    level: 1
+  }) : _chalk;
+}
+
+function highlight(code, options = {}) {
+  if (code !== "" && shouldHighlight(options)) {
+    const chalk = getChalk(options);
+    const defs = getDefs(chalk);
+    return highlightTokens(defs, code);
+  } else {
+    return code;
+  }
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/highlight/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@babel/highlight",
+  "version": "7.17.9",
+  "description": "Syntax highlight JavaScript strings for output in terminals.",
+  "author": "The Babel Team (https://babel.dev/team)",
+  "homepage": "https://babel.dev/docs/en/next/babel-highlight",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-highlight"
+  },
+  "main": "./lib/index.js",
+  "dependencies": {
+    "@babel/helper-validator-identifier": "^7.16.7",
+    "chalk": "^2.0.0",
+    "js-tokens": "^4.0.0"
+  },
+  "devDependencies": {
+    "@types/chalk": "^2.0.0",
+    "strip-ansi": "^4.0.0"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  }
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/parser/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2012-2014 by various contributors (see AUTHORS)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

node_modules/light-bolt11-decoder/examples/node_modules/@babel/parser/README.md

@@ -0,0 +1,19 @@
+# @babel/parser
+
+> A JavaScript parser
+
+See our website [@babel/parser](https://babeljs.io/docs/en/babel-parser) for more information or the [issues](https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20parser%20(babylon)%22+is%3Aopen) associated with this package.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/parser
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/parser --dev
+```

node_modules/light-bolt11-decoder/examples/node_modules/@babel/parser/bin/babel-parser.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+/* eslint no-var: 0 */
+
+var parser = require("..");
+var fs = require("fs");
+
+var filename = process.argv[2];
+if (!filename) {
+  console.error("no filename specified");
+} else {
+  var file = fs.readFileSync(filename, "utf8");
+  var ast = parser.parse(file);
+
+  console.log(JSON.stringify(ast, null, "  "));
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/parser/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@babel/parser",
+  "version": "7.17.9",
+  "description": "A JavaScript parser",
+  "author": "The Babel Team (https://babel.dev/team)",
+  "homepage": "https://babel.dev/docs/en/next/babel-parser",
+  "bugs": "https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A+parser+%28babylon%29%22+is%3Aopen",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "babel",
+    "javascript",
+    "parser",
+    "tc39",
+    "ecmascript",
+    "@babel/parser"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-parser"
+  },
+  "main": "./lib/index.js",
+  "types": "./typings/babel-parser.d.ts",
+  "files": [
+    "bin",
+    "lib",
+    "typings"
+  ],
+  "engines": {
+    "node": ">=6.0.0"
+  },
+  "devDependencies": {
+    "@babel/code-frame": "^7.16.7",
+    "@babel/helper-check-duplicate-nodes": "^7.17.9",
+    "@babel/helper-fixtures": "^7.17.0",
+    "@babel/helper-validator-identifier": "^7.16.7",
+    "charcodes": "^0.2.0"
+  },
+  "bin": "./bin/babel-parser.js"
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/parser/typings/babel-parser.d.ts

@@ -0,0 +1,206 @@
+// Type definitions for @babel/parser
+// Project: https://github.com/babel/babel/tree/main/packages/babel-parser
+// Definitions by: Troy Gerwien <https://github.com/yortus>
+//                 Marvin Hagemeister <https://github.com/marvinhagemeister>
+//                 Avi Vahl <https://github.com/AviVahl>
+// TypeScript Version: 2.9
+
+/**
+ * Parse the provided code as an entire ECMAScript program.
+ */
+export function parse(
+  input: string,
+  options?: ParserOptions
+): ParseResult<import("@babel/types").File>;
+
+/**
+ * Parse the provided code as a single expression.
+ */
+export function parseExpression(
+  input: string,
+  options?: ParserOptions
+): ParseResult<import("@babel/types").Expression>;
+
+export interface ParserOptions {
+  /**
+   * By default, import and export declarations can only appear at a program's top level.
+   * Setting this option to true allows them anywhere where a statement is allowed.
+   */
+  allowImportExportEverywhere?: boolean;
+
+  /**
+   * By default, await use is not allowed outside of an async function.
+   * Set this to true to accept such code.
+   */
+  allowAwaitOutsideFunction?: boolean;
+
+  /**
+   * By default, a return statement at the top level raises an error.
+   * Set this to true to accept such code.
+   */
+  allowReturnOutsideFunction?: boolean;
+
+  allowSuperOutsideMethod?: boolean;
+
+  /**
+   * By default, exported identifiers must refer to a declared variable.
+   * Set this to true to allow export statements to reference undeclared variables.
+   */
+  allowUndeclaredExports?: boolean;
+
+  /**
+   * By default, Babel attaches comments to adjacent AST nodes.
+   * When this option is set to false, comments are not attached.
+   * It can provide up to 30% performance improvement when the input code has many comments.
+   * @babel/eslint-parser will set it for you.
+   * It is not recommended to use attachComment: false with Babel transform,
+   * as doing so removes all the comments in output code, and renders annotations such as
+   * /* istanbul ignore next *\/ nonfunctional.
+   */
+  attachComment?: boolean;
+
+  /**
+   * By default, Babel always throws an error when it finds some invalid code.
+   * When this option is set to true, it will store the parsing error and
+   * try to continue parsing the invalid input file.
+   */
+  errorRecovery?: boolean;
+
+  /**
+   * Indicate the mode the code should be parsed in.
+   * Can be one of "script", "module", or "unambiguous". Defaults to "script".
+   * "unambiguous" will make @babel/parser attempt to guess, based on the presence
+   * of ES6 import or export statements.
+   * Files with ES6 imports and exports are considered "module" and are otherwise "script".
+   */
+  sourceType?: "script" | "module" | "unambiguous";
+
+  /**
+   * Correlate output AST nodes with their source filename.
+   * Useful when generating code and source maps from the ASTs of multiple input files.
+   */
+  sourceFilename?: string;
+
+  /**
+   * By default, the first line of code parsed is treated as line 1.
+   * You can provide a line number to alternatively start with.
+   * Useful for integration with other source tools.
+   */
+  startLine?: number;
+
+  /**
+   * Array containing the plugins that you want to enable.
+   */
+  plugins?: ParserPlugin[];
+
+  /**
+   * Should the parser work in strict mode.
+   * Defaults to true if sourceType === 'module'. Otherwise, false.
+   */
+  strictMode?: boolean;
+
+  /**
+   * Adds a ranges property to each node: [node.start, node.end]
+   */
+  ranges?: boolean;
+
+  /**
+   * Adds all parsed tokens to a tokens property on the File node.
+   */
+  tokens?: boolean;
+
+  /**
+   * By default, the parser adds information about parentheses by setting
+   * `extra.parenthesized` to `true` as needed.
+   * When this option is `true` the parser creates `ParenthesizedExpression`
+   * AST nodes instead of using the `extra` property.
+   */
+  createParenthesizedExpressions?: boolean;
+}
+
+export type ParserPlugin =
+  | "asyncDoExpressions"
+  | "asyncGenerators"
+  | "bigInt"
+  | "classPrivateMethods"
+  | "classPrivateProperties"
+  | "classProperties"
+  | "classStaticBlock" // Enabled by default
+  | "decimal"
+  | "decorators"
+  | "decorators-legacy"
+  | "decoratorAutoAccessors"
+  | "destructuringPrivate"
+  | "doExpressions"
+  | "dynamicImport"
+  | "estree"
+  | "exportDefaultFrom"
+  | "exportNamespaceFrom" // deprecated
+  | "flow"
+  | "flowComments"
+  | "functionBind"
+  | "functionSent"
+  | "importMeta"
+  | "jsx"
+  | "logicalAssignment"
+  | "importAssertions"
+  | "moduleBlocks"
+  | "moduleStringNames"
+  | "nullishCoalescingOperator"
+  | "numericSeparator"
+  | "objectRestSpread"
+  | "optionalCatchBinding"
+  | "optionalChaining"
+  | "partialApplication"
+  | "pipelineOperator"
+  | "placeholders"
+  | "privateIn" // Enabled by default
+  | "regexpUnicodeSets"
+  | "throwExpressions"
+  | "topLevelAwait"
+  | "typescript"
+  | "v8intrinsic"
+  | ParserPluginWithOptions;
+
+export type ParserPluginWithOptions =
+  | ["decorators", DecoratorsPluginOptions]
+  | ["pipelineOperator", PipelineOperatorPluginOptions]
+  | ["recordAndTuple", RecordAndTuplePluginOptions]
+  | ["flow", FlowPluginOptions]
+  | ["typescript", TypeScriptPluginOptions];
+
+export interface DecoratorsPluginOptions {
+  decoratorsBeforeExport?: boolean;
+}
+
+export interface PipelineOperatorPluginOptions {
+  proposal: "minimal" | "fsharp" | "hack" | "smart";
+  topicToken?: "%" | "#" | "@@" | "^^";
+}
+
+export interface RecordAndTuplePluginOptions {
+  syntaxType: "bar" | "hash";
+}
+
+export interface FlowPluginOptions {
+  all?: boolean;
+}
+
+export interface TypeScriptPluginOptions {
+  dts?: boolean;
+  disallowAmbiguousJSXLike?: boolean;
+}
+
+export const tokTypes: {
+  // todo(flow->ts) real token type
+  [name: string]: any;
+};
+
+export interface ParseError {
+  code: string;
+  reasonCode: string;
+}
+
+type ParseResult<Result> = Result & {
+  errors: ParseError[];
+};

node_modules/light-bolt11-decoder/examples/node_modules/@babel/template/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/light-bolt11-decoder/examples/node_modules/@babel/template/README.md

@@ -0,0 +1,19 @@
+# @babel/template
+
+> Generate an AST from a string template.
+
+See our website [@babel/template](https://babeljs.io/docs/en/babel-template) for more information or the [issues](https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20template%22+is%3Aopen) associated with this package.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/template
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/template --dev
+```

node_modules/light-bolt11-decoder/examples/node_modules/@babel/template/lib/builder.js

@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = createTemplateBuilder;
+
+var _options = require("./options");
+
+var _string = require("./string");
+
+var _literal = require("./literal");
+
+const NO_PLACEHOLDER = (0, _options.validate)({
+  placeholderPattern: false
+});
+
+function createTemplateBuilder(formatter, defaultOpts) {
+  const templateFnCache = new WeakMap();
+  const templateAstCache = new WeakMap();
+  const cachedOpts = defaultOpts || (0, _options.validate)(null);
+  return Object.assign((tpl, ...args) => {
+    if (typeof tpl === "string") {
+      if (args.length > 1) throw new Error("Unexpected extra params.");
+      return extendedTrace((0, _string.default)(formatter, tpl, (0, _options.merge)(cachedOpts, (0, _options.validate)(args[0]))));
+    } else if (Array.isArray(tpl)) {
+      let builder = templateFnCache.get(tpl);
+
+      if (!builder) {
+        builder = (0, _literal.default)(formatter, tpl, cachedOpts);
+        templateFnCache.set(tpl, builder);
+      }
+
+      return extendedTrace(builder(args));
+    } else if (typeof tpl === "object" && tpl) {
+      if (args.length > 0) throw new Error("Unexpected extra params.");
+      return createTemplateBuilder(formatter, (0, _options.merge)(cachedOpts, (0, _options.validate)(tpl)));
+    }
+
+    throw new Error(`Unexpected template param ${typeof tpl}`);
+  }, {
+    ast: (tpl, ...args) => {
+      if (typeof tpl === "string") {
+        if (args.length > 1) throw new Error("Unexpected extra params.");
+        return (0, _string.default)(formatter, tpl, (0, _options.merge)((0, _options.merge)(cachedOpts, (0, _options.validate)(args[0])), NO_PLACEHOLDER))();
+      } else if (Array.isArray(tpl)) {
+        let builder = templateAstCache.get(tpl);
+
+        if (!builder) {
+          builder = (0, _literal.default)(formatter, tpl, (0, _options.merge)(cachedOpts, NO_PLACEHOLDER));
+          templateAstCache.set(tpl, builder);
+        }
+
+        return builder(args)();
+      }
+
+      throw new Error(`Unexpected template param ${typeof tpl}`);
+    }
+  });
+}
+
+function extendedTrace(fn) {
+  let rootStack = "";
+
+  try {
+    throw new Error();
+  } catch (error) {
+    if (error.stack) {
+      rootStack = error.stack.split("\n").slice(3).join("\n");
+    }
+  }
+
+  return arg => {
+    try {
+      return fn(arg);
+    } catch (err) {
+      err.stack += `\n    =============\n${rootStack}`;
+      throw err;
+    }
+  };
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/template/lib/formatters.js

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.statements = exports.statement = exports.smart = exports.program = exports.expression = void 0;
+
+var _t = require("@babel/types");
+
+const {
+  assertExpressionStatement
+} = _t;
+
+function makeStatementFormatter(fn) {
+  return {
+    code: str => `/* @babel/template */;\n${str}`,
+    validate: () => {},
+    unwrap: ast => {
+      return fn(ast.program.body.slice(1));
+    }
+  };
+}
+
+const smart = makeStatementFormatter(body => {
+  if (body.length > 1) {
+    return body;
+  } else {
+    return body[0];
+  }
+});
+exports.smart = smart;
+const statements = makeStatementFormatter(body => body);
+exports.statements = statements;
+const statement = makeStatementFormatter(body => {
+  if (body.length === 0) {
+    throw new Error("Found nothing to return.");
+  }
+
+  if (body.length > 1) {
+    throw new Error("Found multiple statements but wanted one");
+  }
+
+  return body[0];
+});
+exports.statement = statement;
+const expression = {
+  code: str => `(\n${str}\n)`,
+  validate: ast => {
+    if (ast.program.body.length > 1) {
+      throw new Error("Found multiple statements but wanted one");
+    }
+
+    if (expression.unwrap(ast).start === 0) {
+      throw new Error("Parse result included parens.");
+    }
+  },
+  unwrap: ({
+    program
+  }) => {
+    const [stmt] = program.body;
+    assertExpressionStatement(stmt);
+    return stmt.expression;
+  }
+};
+exports.expression = expression;
+const program = {
+  code: str => str,
+  validate: () => {},
+  unwrap: ast => ast.program
+};
+exports.program = program;

node_modules/light-bolt11-decoder/examples/node_modules/@babel/template/lib/index.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.statements = exports.statement = exports.smart = exports.program = exports.expression = exports.default = void 0;
+
+var formatters = require("./formatters");
+
+var _builder = require("./builder");
+
+const smart = (0, _builder.default)(formatters.smart);
+exports.smart = smart;
+const statement = (0, _builder.default)(formatters.statement);
+exports.statement = statement;
+const statements = (0, _builder.default)(formatters.statements);
+exports.statements = statements;
+const expression = (0, _builder.default)(formatters.expression);
+exports.expression = expression;
+const program = (0, _builder.default)(formatters.program);
+exports.program = program;
+
+var _default = Object.assign(smart.bind(undefined), {
+  smart,
+  statement,
+  statements,
+  expression,
+  program,
+  ast: smart.ast
+});
+
+exports.default = _default;

node_modules/light-bolt11-decoder/examples/node_modules/@babel/template/lib/literal.js

@@ -0,0 +1,80 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = literalTemplate;
+
+var _options = require("./options");
+
+var _parse = require("./parse");
+
+var _populate = require("./populate");
+
+function literalTemplate(formatter, tpl, opts) {
+  const {
+    metadata,
+    names
+  } = buildLiteralData(formatter, tpl, opts);
+  return arg => {
+    const defaultReplacements = {};
+    arg.forEach((replacement, i) => {
+      defaultReplacements[names[i]] = replacement;
+    });
+    return arg => {
+      const replacements = (0, _options.normalizeReplacements)(arg);
+
+      if (replacements) {
+        Object.keys(replacements).forEach(key => {
+          if (Object.prototype.hasOwnProperty.call(defaultReplacements, key)) {
+            throw new Error("Unexpected replacement overlap.");
+          }
+        });
+      }
+
+      return formatter.unwrap((0, _populate.default)(metadata, replacements ? Object.assign(replacements, defaultReplacements) : defaultReplacements));
+    };
+  };
+}
+
+function buildLiteralData(formatter, tpl, opts) {
+  let names;
+  let nameSet;
+  let metadata;
+  let prefix = "";
+
+  do {
+    prefix += "$";
+    const result = buildTemplateCode(tpl, prefix);
+    names = result.names;
+    nameSet = new Set(names);
+    metadata = (0, _parse.default)(formatter, formatter.code(result.code), {
+      parser: opts.parser,
+      placeholderWhitelist: new Set(result.names.concat(opts.placeholderWhitelist ? Array.from(opts.placeholderWhitelist) : [])),
+      placeholderPattern: opts.placeholderPattern,
+      preserveComments: opts.preserveComments,
+      syntacticPlaceholders: opts.syntacticPlaceholders
+    });
+  } while (metadata.placeholders.some(placeholder => placeholder.isDuplicate && nameSet.has(placeholder.name)));
+
+  return {
+    metadata,
+    names
+  };
+}
+
+function buildTemplateCode(tpl, prefix) {
+  const names = [];
+  let code = tpl[0];
+
+  for (let i = 1; i < tpl.length; i++) {
+    const value = `${prefix}${i - 1}`;
+    names.push(value);
+    code += value + tpl[i];
+  }
+
+  return {
+    names,
+    code
+  };
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/template/lib/options.js

@@ -0,0 +1,83 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.merge = merge;
+exports.normalizeReplacements = normalizeReplacements;
+exports.validate = validate;
+const _excluded = ["placeholderWhitelist", "placeholderPattern", "preserveComments", "syntacticPlaceholders"];
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+function merge(a, b) {
+  const {
+    placeholderWhitelist = a.placeholderWhitelist,
+    placeholderPattern = a.placeholderPattern,
+    preserveComments = a.preserveComments,
+    syntacticPlaceholders = a.syntacticPlaceholders
+  } = b;
+  return {
+    parser: Object.assign({}, a.parser, b.parser),
+    placeholderWhitelist,
+    placeholderPattern,
+    preserveComments,
+    syntacticPlaceholders
+  };
+}
+
+function validate(opts) {
+  if (opts != null && typeof opts !== "object") {
+    throw new Error("Unknown template options.");
+  }
+
+  const _ref = opts || {},
+        {
+    placeholderWhitelist,
+    placeholderPattern,
+    preserveComments,
+    syntacticPlaceholders
+  } = _ref,
+        parser = _objectWithoutPropertiesLoose(_ref, _excluded);
+
+  if (placeholderWhitelist != null && !(placeholderWhitelist instanceof Set)) {
+    throw new Error("'.placeholderWhitelist' must be a Set, null, or undefined");
+  }
+
+  if (placeholderPattern != null && !(placeholderPattern instanceof RegExp) && placeholderPattern !== false) {
+    throw new Error("'.placeholderPattern' must be a RegExp, false, null, or undefined");
+  }
+
+  if (preserveComments != null && typeof preserveComments !== "boolean") {
+    throw new Error("'.preserveComments' must be a boolean, null, or undefined");
+  }
+
+  if (syntacticPlaceholders != null && typeof syntacticPlaceholders !== "boolean") {
+    throw new Error("'.syntacticPlaceholders' must be a boolean, null, or undefined");
+  }
+
+  if (syntacticPlaceholders === true && (placeholderWhitelist != null || placeholderPattern != null)) {
+    throw new Error("'.placeholderWhitelist' and '.placeholderPattern' aren't compatible" + " with '.syntacticPlaceholders: true'");
+  }
+
+  return {
+    parser,
+    placeholderWhitelist: placeholderWhitelist || undefined,
+    placeholderPattern: placeholderPattern == null ? undefined : placeholderPattern,
+    preserveComments: preserveComments == null ? undefined : preserveComments,
+    syntacticPlaceholders: syntacticPlaceholders == null ? undefined : syntacticPlaceholders
+  };
+}
+
+function normalizeReplacements(replacements) {
+  if (Array.isArray(replacements)) {
+    return replacements.reduce((acc, replacement, i) => {
+      acc["$" + i] = replacement;
+      return acc;
+    }, {});
+  } else if (typeof replacements === "object" || replacements == null) {
+    return replacements || undefined;
+  }
+
+  throw new Error("Template replacements must be an array, object, null, or undefined");
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/template/lib/parse.js

@@ -0,0 +1,188 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = parseAndBuildMetadata;
+
+var _t = require("@babel/types");
+
+var _parser = require("@babel/parser");
+
+var _codeFrame = require("@babel/code-frame");
+
+const {
+  isCallExpression,
+  isExpressionStatement,
+  isFunction,
+  isIdentifier,
+  isJSXIdentifier,
+  isNewExpression,
+  isPlaceholder,
+  isStatement,
+  isStringLiteral,
+  removePropertiesDeep,
+  traverse
+} = _t;
+const PATTERN = /^[_$A-Z0-9]+$/;
+
+function parseAndBuildMetadata(formatter, code, opts) {
+  const {
+    placeholderWhitelist,
+    placeholderPattern,
+    preserveComments,
+    syntacticPlaceholders
+  } = opts;
+  const ast = parseWithCodeFrame(code, opts.parser, syntacticPlaceholders);
+  removePropertiesDeep(ast, {
+    preserveComments
+  });
+  formatter.validate(ast);
+  const syntactic = {
+    placeholders: [],
+    placeholderNames: new Set()
+  };
+  const legacy = {
+    placeholders: [],
+    placeholderNames: new Set()
+  };
+  const isLegacyRef = {
+    value: undefined
+  };
+  traverse(ast, placeholderVisitorHandler, {
+    syntactic,
+    legacy,
+    isLegacyRef,
+    placeholderWhitelist,
+    placeholderPattern,
+    syntacticPlaceholders
+  });
+  return Object.assign({
+    ast
+  }, isLegacyRef.value ? legacy : syntactic);
+}
+
+function placeholderVisitorHandler(node, ancestors, state) {
+  var _state$placeholderWhi;
+
+  let name;
+
+  if (isPlaceholder(node)) {
+    if (state.syntacticPlaceholders === false) {
+      throw new Error("%%foo%%-style placeholders can't be used when " + "'.syntacticPlaceholders' is false.");
+    } else {
+      name = node.name.name;
+      state.isLegacyRef.value = false;
+    }
+  } else if (state.isLegacyRef.value === false || state.syntacticPlaceholders) {
+    return;
+  } else if (isIdentifier(node) || isJSXIdentifier(node)) {
+    name = node.name;
+    state.isLegacyRef.value = true;
+  } else if (isStringLiteral(node)) {
+    name = node.value;
+    state.isLegacyRef.value = true;
+  } else {
+    return;
+  }
+
+  if (!state.isLegacyRef.value && (state.placeholderPattern != null || state.placeholderWhitelist != null)) {
+    throw new Error("'.placeholderWhitelist' and '.placeholderPattern' aren't compatible" + " with '.syntacticPlaceholders: true'");
+  }
+
+  if (state.isLegacyRef.value && (state.placeholderPattern === false || !(state.placeholderPattern || PATTERN).test(name)) && !((_state$placeholderWhi = state.placeholderWhitelist) != null && _state$placeholderWhi.has(name))) {
+    return;
+  }
+
+  ancestors = ancestors.slice();
+  const {
+    node: parent,
+    key
+  } = ancestors[ancestors.length - 1];
+  let type;
+
+  if (isStringLiteral(node) || isPlaceholder(node, {
+    expectedNode: "StringLiteral"
+  })) {
+    type = "string";
+  } else if (isNewExpression(parent) && key === "arguments" || isCallExpression(parent) && key === "arguments" || isFunction(parent) && key === "params") {
+    type = "param";
+  } else if (isExpressionStatement(parent) && !isPlaceholder(node)) {
+    type = "statement";
+    ancestors = ancestors.slice(0, -1);
+  } else if (isStatement(node) && isPlaceholder(node)) {
+    type = "statement";
+  } else {
+    type = "other";
+  }
+
+  const {
+    placeholders,
+    placeholderNames
+  } = state.isLegacyRef.value ? state.legacy : state.syntactic;
+  placeholders.push({
+    name,
+    type,
+    resolve: ast => resolveAncestors(ast, ancestors),
+    isDuplicate: placeholderNames.has(name)
+  });
+  placeholderNames.add(name);
+}
+
+function resolveAncestors(ast, ancestors) {
+  let parent = ast;
+
+  for (let i = 0; i < ancestors.length - 1; i++) {
+    const {
+      key,
+      index
+    } = ancestors[i];
+
+    if (index === undefined) {
+      parent = parent[key];
+    } else {
+      parent = parent[key][index];
+    }
+  }
+
+  const {
+    key,
+    index
+  } = ancestors[ancestors.length - 1];
+  return {
+    parent,
+    key,
+    index
+  };
+}
+
+function parseWithCodeFrame(code, parserOpts, syntacticPlaceholders) {
+  const plugins = (parserOpts.plugins || []).slice();
+
+  if (syntacticPlaceholders !== false) {
+    plugins.push("placeholders");
+  }
+
+  parserOpts = Object.assign({
+    allowReturnOutsideFunction: true,
+    allowSuperOutsideMethod: true,
+    sourceType: "module"
+  }, parserOpts, {
+    plugins
+  });
+
+  try {
+    return (0, _parser.parse)(code, parserOpts);
+  } catch (err) {
+    const loc = err.loc;
+
+    if (loc) {
+      err.message += "\n" + (0, _codeFrame.codeFrameColumns)(code, {
+        start: loc
+      });
+      err.code = "BABEL_TEMPLATE_PARSE_ERROR";
+    }
+
+    throw err;
+  }
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/template/lib/populate.js

@@ -0,0 +1,135 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = populatePlaceholders;
+
+var _t = require("@babel/types");
+
+const {
+  blockStatement,
+  cloneNode,
+  emptyStatement,
+  expressionStatement,
+  identifier,
+  isStatement,
+  isStringLiteral,
+  stringLiteral,
+  validate
+} = _t;
+
+function populatePlaceholders(metadata, replacements) {
+  const ast = cloneNode(metadata.ast);
+
+  if (replacements) {
+    metadata.placeholders.forEach(placeholder => {
+      if (!Object.prototype.hasOwnProperty.call(replacements, placeholder.name)) {
+        const placeholderName = placeholder.name;
+        throw new Error(`Error: No substitution given for "${placeholderName}". If this is not meant to be a
+            placeholder you may want to consider passing one of the following options to @babel/template:
+            - { placeholderPattern: false, placeholderWhitelist: new Set(['${placeholderName}'])}
+            - { placeholderPattern: /^${placeholderName}$/ }`);
+      }
+    });
+    Object.keys(replacements).forEach(key => {
+      if (!metadata.placeholderNames.has(key)) {
+        throw new Error(`Unknown substitution "${key}" given`);
+      }
+    });
+  }
+
+  metadata.placeholders.slice().reverse().forEach(placeholder => {
+    try {
+      applyReplacement(placeholder, ast, replacements && replacements[placeholder.name] || null);
+    } catch (e) {
+      e.message = `@babel/template placeholder "${placeholder.name}": ${e.message}`;
+      throw e;
+    }
+  });
+  return ast;
+}
+
+function applyReplacement(placeholder, ast, replacement) {
+  if (placeholder.isDuplicate) {
+    if (Array.isArray(replacement)) {
+      replacement = replacement.map(node => cloneNode(node));
+    } else if (typeof replacement === "object") {
+      replacement = cloneNode(replacement);
+    }
+  }
+
+  const {
+    parent,
+    key,
+    index
+  } = placeholder.resolve(ast);
+
+  if (placeholder.type === "string") {
+    if (typeof replacement === "string") {
+      replacement = stringLiteral(replacement);
+    }
+
+    if (!replacement || !isStringLiteral(replacement)) {
+      throw new Error("Expected string substitution");
+    }
+  } else if (placeholder.type === "statement") {
+    if (index === undefined) {
+      if (!replacement) {
+        replacement = emptyStatement();
+      } else if (Array.isArray(replacement)) {
+        replacement = blockStatement(replacement);
+      } else if (typeof replacement === "string") {
+        replacement = expressionStatement(identifier(replacement));
+      } else if (!isStatement(replacement)) {
+        replacement = expressionStatement(replacement);
+      }
+    } else {
+      if (replacement && !Array.isArray(replacement)) {
+        if (typeof replacement === "string") {
+          replacement = identifier(replacement);
+        }
+
+        if (!isStatement(replacement)) {
+          replacement = expressionStatement(replacement);
+        }
+      }
+    }
+  } else if (placeholder.type === "param") {
+    if (typeof replacement === "string") {
+      replacement = identifier(replacement);
+    }
+
+    if (index === undefined) throw new Error("Assertion failure.");
+  } else {
+    if (typeof replacement === "string") {
+      replacement = identifier(replacement);
+    }
+
+    if (Array.isArray(replacement)) {
+      throw new Error("Cannot replace single expression with an array.");
+    }
+  }
+
+  if (index === undefined) {
+    validate(parent, key, replacement);
+    parent[key] = replacement;
+  } else {
+    const items = parent[key].slice();
+
+    if (placeholder.type === "statement" || placeholder.type === "param") {
+      if (replacement == null) {
+        items.splice(index, 1);
+      } else if (Array.isArray(replacement)) {
+        items.splice(index, 1, ...replacement);
+      } else {
+        items[index] = replacement;
+      }
+    } else {
+      items[index] = replacement;
+    }
+
+    validate(parent, key, items);
+    parent[key] = items;
+  }
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/template/lib/string.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = stringTemplate;
+
+var _options = require("./options");
+
+var _parse = require("./parse");
+
+var _populate = require("./populate");
+
+function stringTemplate(formatter, code, opts) {
+  code = formatter.code(code);
+  let metadata;
+  return arg => {
+    const replacements = (0, _options.normalizeReplacements)(arg);
+    if (!metadata) metadata = (0, _parse.default)(formatter, code, opts);
+    return formatter.unwrap((0, _populate.default)(metadata, replacements));
+  };
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/template/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@babel/template",
+  "version": "7.16.7",
+  "description": "Generate an AST from a string template.",
+  "author": "The Babel Team (https://babel.dev/team)",
+  "homepage": "https://babel.dev/docs/en/next/babel-template",
+  "bugs": "https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20template%22+is%3Aopen",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-template"
+  },
+  "main": "./lib/index.js",
+  "dependencies": {
+    "@babel/code-frame": "^7.16.7",
+    "@babel/parser": "^7.16.7",
+    "@babel/types": "^7.16.7"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  }
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/traverse/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/light-bolt11-decoder/examples/node_modules/@babel/traverse/README.md

@@ -0,0 +1,19 @@
+# @babel/traverse
+
+> The Babel Traverse module maintains the overall tree state, and is responsible for replacing, removing, and adding nodes
+
+See our website [@babel/traverse](https://babeljs.io/docs/en/babel-traverse) for more information or the [issues](https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20traverse%22+is%3Aopen) associated with this package.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/traverse
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/traverse --dev
+```

node_modules/light-bolt11-decoder/examples/node_modules/@babel/traverse/lib/cache.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.clear = clear;
+exports.clearPath = clearPath;
+exports.clearScope = clearScope;
+exports.scope = exports.path = void 0;
+let path = new WeakMap();
+exports.path = path;
+let scope = new WeakMap();
+exports.scope = scope;
+
+function clear() {
+  clearPath();
+  clearScope();
+}
+
+function clearPath() {
+  exports.path = path = new WeakMap();
+}
+
+function clearScope() {
+  exports.scope = scope = new WeakMap();
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/traverse/lib/context.js

@@ -0,0 +1,137 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _path = require("./path");
+
+var _t = require("@babel/types");
+
+const {
+  VISITOR_KEYS
+} = _t;
+
+class TraversalContext {
+  constructor(scope, opts, state, parentPath) {
+    this.queue = null;
+    this.priorityQueue = null;
+    this.parentPath = parentPath;
+    this.scope = scope;
+    this.state = state;
+    this.opts = opts;
+  }
+
+  shouldVisit(node) {
+    const opts = this.opts;
+    if (opts.enter || opts.exit) return true;
+    if (opts[node.type]) return true;
+    const keys = VISITOR_KEYS[node.type];
+    if (!(keys != null && keys.length)) return false;
+
+    for (const key of keys) {
+      if (node[key]) return true;
+    }
+
+    return false;
+  }
+
+  create(node, obj, key, listKey) {
+    return _path.default.get({
+      parentPath: this.parentPath,
+      parent: node,
+      container: obj,
+      key: key,
+      listKey
+    });
+  }
+
+  maybeQueue(path, notPriority) {
+    if (this.queue) {
+      if (notPriority) {
+        this.queue.push(path);
+      } else {
+        this.priorityQueue.push(path);
+      }
+    }
+  }
+
+  visitMultiple(container, parent, listKey) {
+    if (container.length === 0) return false;
+    const queue = [];
+
+    for (let key = 0; key < container.length; key++) {
+      const node = container[key];
+
+      if (node && this.shouldVisit(node)) {
+        queue.push(this.create(parent, container, key, listKey));
+      }
+    }
+
+    return this.visitQueue(queue);
+  }
+
+  visitSingle(node, key) {
+    if (this.shouldVisit(node[key])) {
+      return this.visitQueue([this.create(node, node, key)]);
+    } else {
+      return false;
+    }
+  }
+
+  visitQueue(queue) {
+    this.queue = queue;
+    this.priorityQueue = [];
+    const visited = new WeakSet();
+    let stop = false;
+
+    for (const path of queue) {
+      path.resync();
+
+      if (path.contexts.length === 0 || path.contexts[path.contexts.length - 1] !== this) {
+        path.pushContext(this);
+      }
+
+      if (path.key === null) continue;
+      const {
+        node
+      } = path;
+      if (visited.has(node)) continue;
+      if (node) visited.add(node);
+
+      if (path.visit()) {
+        stop = true;
+        break;
+      }
+
+      if (this.priorityQueue.length) {
+        stop = this.visitQueue(this.priorityQueue);
+        this.priorityQueue = [];
+        this.queue = queue;
+        if (stop) break;
+      }
+    }
+
+    for (const path of queue) {
+      path.popContext();
+    }
+
+    this.queue = null;
+    return stop;
+  }
+
+  visit(node, key) {
+    const nodes = node[key];
+    if (!nodes) return false;
+
+    if (Array.isArray(nodes)) {
+      return this.visitMultiple(nodes, node, key);
+    } else {
+      return this.visitSingle(node, key);
+    }
+  }
+
+}
+
+exports.default = TraversalContext;

node_modules/light-bolt11-decoder/examples/node_modules/@babel/traverse/lib/hub.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+class Hub {
+  getCode() {}
+
+  getScope() {}
+
+  addHelper() {
+    throw new Error("Helpers are not supported by the default hub.");
+  }
+
+  buildError(node, msg, Error = TypeError) {
+    return new Error(msg);
+  }
+
+}
+
+exports.default = Hub;

node_modules/light-bolt11-decoder/examples/node_modules/@babel/traverse/lib/index.js

@@ -0,0 +1,111 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Hub", {
+  enumerable: true,
+  get: function () {
+    return _hub.default;
+  }
+});
+Object.defineProperty(exports, "NodePath", {
+  enumerable: true,
+  get: function () {
+    return _path.default;
+  }
+});
+Object.defineProperty(exports, "Scope", {
+  enumerable: true,
+  get: function () {
+    return _scope.default;
+  }
+});
+exports.visitors = exports.default = void 0;
+
+var visitors = require("./visitors");
+
+exports.visitors = visitors;
+
+var _t = require("@babel/types");
+
+var cache = require("./cache");
+
+var _traverseNode = require("./traverse-node");
+
+var _path = require("./path");
+
+var _scope = require("./scope");
+
+var _hub = require("./hub");
+
+const {
+  VISITOR_KEYS,
+  removeProperties,
+  traverseFast
+} = _t;
+
+function traverse(parent, opts = {}, scope, state, parentPath) {
+  if (!parent) return;
+
+  if (!opts.noScope && !scope) {
+    if (parent.type !== "Program" && parent.type !== "File") {
+      throw new Error("You must pass a scope and parentPath unless traversing a Program/File. " + `Instead of that you tried to traverse a ${parent.type} node without ` + "passing scope and parentPath.");
+    }
+  }
+
+  if (!VISITOR_KEYS[parent.type]) {
+    return;
+  }
+
+  visitors.explode(opts);
+  (0, _traverseNode.traverseNode)(parent, opts, scope, state, parentPath);
+}
+
+var _default = traverse;
+exports.default = _default;
+traverse.visitors = visitors;
+traverse.verify = visitors.verify;
+traverse.explode = visitors.explode;
+
+traverse.cheap = function (node, enter) {
+  return traverseFast(node, enter);
+};
+
+traverse.node = function (node, opts, scope, state, path, skipKeys) {
+  (0, _traverseNode.traverseNode)(node, opts, scope, state, path, skipKeys);
+};
+
+traverse.clearNode = function (node, opts) {
+  removeProperties(node, opts);
+  cache.path.delete(node);
+};
+
+traverse.removeProperties = function (tree, opts) {
+  traverseFast(tree, traverse.clearNode, opts);
+  return tree;
+};
+
+function hasDenylistedType(path, state) {
+  if (path.node.type === state.type) {
+    state.has = true;
+    path.stop();
+  }
+}
+
+traverse.hasType = function (tree, type, denylistTypes) {
+  if (denylistTypes != null && denylistTypes.includes(tree.type)) return false;
+  if (tree.type === type) return true;
+  const state = {
+    has: false,
+    type: type
+  };
+  traverse(tree, {
+    noScope: true,
+    denylist: denylistTypes,
+    enter: hasDenylistedType
+  }, null, state);
+  return state.has;
+};
+
+traverse.cache = cache;

node_modules/light-bolt11-decoder/examples/node_modules/@babel/traverse/lib/path/ancestry.js

@@ -0,0 +1,180 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.find = find;
+exports.findParent = findParent;
+exports.getAncestry = getAncestry;
+exports.getDeepestCommonAncestorFrom = getDeepestCommonAncestorFrom;
+exports.getEarliestCommonAncestorFrom = getEarliestCommonAncestorFrom;
+exports.getFunctionParent = getFunctionParent;
+exports.getStatementParent = getStatementParent;
+exports.inType = inType;
+exports.isAncestor = isAncestor;
+exports.isDescendant = isDescendant;
+
+var _t = require("@babel/types");
+
+var _index = require("./index");
+
+const {
+  VISITOR_KEYS
+} = _t;
+
+function findParent(callback) {
+  let path = this;
+
+  while (path = path.parentPath) {
+    if (callback(path)) return path;
+  }
+
+  return null;
+}
+
+function find(callback) {
+  let path = this;
+
+  do {
+    if (callback(path)) return path;
+  } while (path = path.parentPath);
+
+  return null;
+}
+
+function getFunctionParent() {
+  return this.findParent(p => p.isFunction());
+}
+
+function getStatementParent() {
+  let path = this;
+
+  do {
+    if (!path.parentPath || Array.isArray(path.container) && path.isStatement()) {
+      break;
+    } else {
+      path = path.parentPath;
+    }
+  } while (path);
+
+  if (path && (path.isProgram() || path.isFile())) {
+    throw new Error("File/Program node, we can't possibly find a statement parent to this");
+  }
+
+  return path;
+}
+
+function getEarliestCommonAncestorFrom(paths) {
+  return this.getDeepestCommonAncestorFrom(paths, function (deepest, i, ancestries) {
+    let earliest;
+    const keys = VISITOR_KEYS[deepest.type];
+
+    for (const ancestry of ancestries) {
+      const path = ancestry[i + 1];
+
+      if (!earliest) {
+        earliest = path;
+        continue;
+      }
+
+      if (path.listKey && earliest.listKey === path.listKey) {
+        if (path.key < earliest.key) {
+          earliest = path;
+          continue;
+        }
+      }
+
+      const earliestKeyIndex = keys.indexOf(earliest.parentKey);
+      const currentKeyIndex = keys.indexOf(path.parentKey);
+
+      if (earliestKeyIndex > currentKeyIndex) {
+        earliest = path;
+      }
+    }
+
+    return earliest;
+  });
+}
+
+function getDeepestCommonAncestorFrom(paths, filter) {
+  if (!paths.length) {
+    return this;
+  }
+
+  if (paths.length === 1) {
+    return paths[0];
+  }
+
+  let minDepth = Infinity;
+  let lastCommonIndex, lastCommon;
+  const ancestries = paths.map(path => {
+    const ancestry = [];
+
+    do {
+      ancestry.unshift(path);
+    } while ((path = path.parentPath) && path !== this);
+
+    if (ancestry.length < minDepth) {
+      minDepth = ancestry.length;
+    }
+
+    return ancestry;
+  });
+  const first = ancestries[0];
+
+  depthLoop: for (let i = 0; i < minDepth; i++) {
+    const shouldMatch = first[i];
+
+    for (const ancestry of ancestries) {
+      if (ancestry[i] !== shouldMatch) {
+        break depthLoop;
+      }
+    }
+
+    lastCommonIndex = i;
+    lastCommon = shouldMatch;
+  }
+
+  if (lastCommon) {
+    if (filter) {
+      return filter(lastCommon, lastCommonIndex, ancestries);
+    } else {
+      return lastCommon;
+    }
+  } else {
+    throw new Error("Couldn't find intersection");
+  }
+}
+
+function getAncestry() {
+  let path = this;
+  const paths = [];
+
+  do {
+    paths.push(path);
+  } while (path = path.parentPath);
+
+  return paths;
+}
+
+function isAncestor(maybeDescendant) {
+  return maybeDescendant.isDescendant(this);
+}
+
+function isDescendant(maybeAncestor) {
+  return !!this.findParent(parent => parent === maybeAncestor);
+}
+
+function inType(...candidateTypes) {
+  let path = this;
+
+  while (path) {
+    for (const type of candidateTypes) {
+      if (path.node.type === type) return true;
+    }
+
+    path = path.parentPath;
+  }
+
+  return false;
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/traverse/lib/path/comments.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addComment = addComment;
+exports.addComments = addComments;
+exports.shareCommentsWithSiblings = shareCommentsWithSiblings;
+
+var _t = require("@babel/types");
+
+const {
+  addComment: _addComment,
+  addComments: _addComments
+} = _t;
+
+function shareCommentsWithSiblings() {
+  if (typeof this.key === "string") return;
+  const node = this.node;
+  if (!node) return;
+  const trailing = node.trailingComments;
+  const leading = node.leadingComments;
+  if (!trailing && !leading) return;
+  const prev = this.getSibling(this.key - 1);
+  const next = this.getSibling(this.key + 1);
+  const hasPrev = Boolean(prev.node);
+  const hasNext = Boolean(next.node);
+
+  if (hasPrev && !hasNext) {
+    prev.addComments("trailing", trailing);
+  } else if (hasNext && !hasPrev) {
+    next.addComments("leading", leading);
+  }
+}
+
+function addComment(type, content, line) {
+  _addComment(this.node, type, content, line);
+}
+
+function addComments(type, comments) {
+  _addComments(this.node, type, comments);
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/traverse/lib/path/context.js

@@ -0,0 +1,263 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports._call = _call;
+exports._getQueueContexts = _getQueueContexts;
+exports._resyncKey = _resyncKey;
+exports._resyncList = _resyncList;
+exports._resyncParent = _resyncParent;
+exports._resyncRemoved = _resyncRemoved;
+exports.call = call;
+exports.isBlacklisted = exports.isDenylisted = isDenylisted;
+exports.popContext = popContext;
+exports.pushContext = pushContext;
+exports.requeue = requeue;
+exports.resync = resync;
+exports.setContext = setContext;
+exports.setKey = setKey;
+exports.setScope = setScope;
+exports.setup = setup;
+exports.skip = skip;
+exports.skipKey = skipKey;
+exports.stop = stop;
+exports.visit = visit;
+
+var _traverseNode = require("../traverse-node");
+
+var _index = require("./index");
+
+function call(key) {
+  const opts = this.opts;
+  this.debug(key);
+
+  if (this.node) {
+    if (this._call(opts[key])) return true;
+  }
+
+  if (this.node) {
+    return this._call(opts[this.node.type] && opts[this.node.type][key]);
+  }
+
+  return false;
+}
+
+function _call(fns) {
+  if (!fns) return false;
+
+  for (const fn of fns) {
+    if (!fn) continue;
+    const node = this.node;
+    if (!node) return true;
+    const ret = fn.call(this.state, this, this.state);
+
+    if (ret && typeof ret === "object" && typeof ret.then === "function") {
+      throw new Error(`You appear to be using a plugin with an async traversal visitor, ` + `which your current version of Babel does not support. ` + `If you're using a published plugin, you may need to upgrade ` + `your @babel/core version.`);
+    }
+
+    if (ret) {
+      throw new Error(`Unexpected return value from visitor method ${fn}`);
+    }
+
+    if (this.node !== node) return true;
+    if (this._traverseFlags > 0) return true;
+  }
+
+  return false;
+}
+
+function isDenylisted() {
+  var _this$opts$denylist;
+
+  const denylist = (_this$opts$denylist = this.opts.denylist) != null ? _this$opts$denylist : this.opts.blacklist;
+  return denylist && denylist.indexOf(this.node.type) > -1;
+}
+
+function restoreContext(path, context) {
+  if (path.context !== context) {
+    path.context = context;
+    path.state = context.state;
+    path.opts = context.opts;
+  }
+}
+
+function visit() {
+  if (!this.node) {
+    return false;
+  }
+
+  if (this.isDenylisted()) {
+    return false;
+  }
+
+  if (this.opts.shouldSkip && this.opts.shouldSkip(this)) {
+    return false;
+  }
+
+  const currentContext = this.context;
+
+  if (this.shouldSkip || this.call("enter")) {
+    this.debug("Skip...");
+    return this.shouldStop;
+  }
+
+  restoreContext(this, currentContext);
+  this.debug("Recursing into...");
+  this.shouldStop = (0, _traverseNode.traverseNode)(this.node, this.opts, this.scope, this.state, this, this.skipKeys);
+  restoreContext(this, currentContext);
+  this.call("exit");
+  return this.shouldStop;
+}
+
+function skip() {
+  this.shouldSkip = true;
+}
+
+function skipKey(key) {
+  if (this.skipKeys == null) {
+    this.skipKeys = {};
+  }
+
+  this.skipKeys[key] = true;
+}
+
+function stop() {
+  this._traverseFlags |= _index.SHOULD_SKIP | _index.SHOULD_STOP;
+}
+
+function setScope() {
+  if (this.opts && this.opts.noScope) return;
+  let path = this.parentPath;
+  if (this.key === "key" && path.isMethod()) path = path.parentPath;
+  let target;
+
+  while (path && !target) {
+    if (path.opts && path.opts.noScope) return;
+    target = path.scope;
+    path = path.parentPath;
+  }
+
+  this.scope = this.getScope(target);
+  if (this.scope) this.scope.init();
+}
+
+function setContext(context) {
+  if (this.skipKeys != null) {
+    this.skipKeys = {};
+  }
+
+  this._traverseFlags = 0;
+
+  if (context) {
+    this.context = context;
+    this.state = context.state;
+    this.opts = context.opts;
+  }
+
+  this.setScope();
+  return this;
+}
+
+function resync() {
+  if (this.removed) return;
+
+  this._resyncParent();
+
+  this._resyncList();
+
+  this._resyncKey();
+}
+
+function _resyncParent() {
+  if (this.parentPath) {
+    this.parent = this.parentPath.node;
+  }
+}
+
+function _resyncKey() {
+  if (!this.container) return;
+  if (this.node === this.container[this.key]) return;
+
+  if (Array.isArray(this.container)) {
+    for (let i = 0; i < this.container.length; i++) {
+      if (this.container[i] === this.node) {
+        return this.setKey(i);
+      }
+    }
+  } else {
+    for (const key of Object.keys(this.container)) {
+      if (this.container[key] === this.node) {
+        return this.setKey(key);
+      }
+    }
+  }
+
+  this.key = null;
+}
+
+function _resyncList() {
+  if (!this.parent || !this.inList) return;
+  const newContainer = this.parent[this.listKey];
+  if (this.container === newContainer) return;
+  this.container = newContainer || null;
+}
+
+function _resyncRemoved() {
+  if (this.key == null || !this.container || this.container[this.key] !== this.node) {
+    this._markRemoved();
+  }
+}
+
+function popContext() {
+  this.contexts.pop();
+
+  if (this.contexts.length > 0) {
+    this.setContext(this.contexts[this.contexts.length - 1]);
+  } else {
+    this.setContext(undefined);
+  }
+}
+
+function pushContext(context) {
+  this.contexts.push(context);
+  this.setContext(context);
+}
+
+function setup(parentPath, container, listKey, key) {
+  this.listKey = listKey;
+  this.container = container;
+  this.parentPath = parentPath || this.parentPath;
+  this.setKey(key);
+}
+
+function setKey(key) {
+  var _this$node;
+
+  this.key = key;
+  this.node = this.container[this.key];
+  this.type = (_this$node = this.node) == null ? void 0 : _this$node.type;
+}
+
+function requeue(pathToQueue = this) {
+  if (pathToQueue.removed) return;
+  ;
+  const contexts = this.contexts;
+
+  for (const context of contexts) {
+    context.maybeQueue(pathToQueue);
+  }
+}
+
+function _getQueueContexts() {
+  let path = this;
+  let contexts = this.contexts;
+
+  while (!contexts.length) {
+    path = path.parentPath;
+    if (!path) break;
+    contexts = path.contexts;
+  }
+
+  return contexts;
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/traverse/lib/path/conversion.js

@@ -0,0 +1,531 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.arrowFunctionToExpression = arrowFunctionToExpression;
+exports.arrowFunctionToShadowed = arrowFunctionToShadowed;
+exports.ensureBlock = ensureBlock;
+exports.toComputedKey = toComputedKey;
+exports.unwrapFunctionEnvironment = unwrapFunctionEnvironment;
+
+var _t = require("@babel/types");
+
+var _helperEnvironmentVisitor = require("@babel/helper-environment-visitor");
+
+var _helperFunctionName = require("@babel/helper-function-name");
+
+var _visitors = require("../visitors");
+
+const {
+  arrowFunctionExpression,
+  assignmentExpression,
+  binaryExpression,
+  blockStatement,
+  callExpression,
+  conditionalExpression,
+  expressionStatement,
+  identifier,
+  isIdentifier,
+  jsxIdentifier,
+  logicalExpression,
+  LOGICAL_OPERATORS,
+  memberExpression,
+  metaProperty,
+  numericLiteral,
+  objectExpression,
+  restElement,
+  returnStatement,
+  sequenceExpression,
+  spreadElement,
+  stringLiteral,
+  super: _super,
+  thisExpression,
+  toExpression,
+  unaryExpression
+} = _t;
+
+function toComputedKey() {
+  let key;
+
+  if (this.isMemberExpression()) {
+    key = this.node.property;
+  } else if (this.isProperty() || this.isMethod()) {
+    key = this.node.key;
+  } else {
+    throw new ReferenceError("todo");
+  }
+
+  if (!this.node.computed) {
+    if (isIdentifier(key)) key = stringLiteral(key.name);
+  }
+
+  return key;
+}
+
+function ensureBlock() {
+  const body = this.get("body");
+  const bodyNode = body.node;
+
+  if (Array.isArray(body)) {
+    throw new Error("Can't convert array path to a block statement");
+  }
+
+  if (!bodyNode) {
+    throw new Error("Can't convert node without a body");
+  }
+
+  if (body.isBlockStatement()) {
+    return bodyNode;
+  }
+
+  const statements = [];
+  let stringPath = "body";
+  let key;
+  let listKey;
+
+  if (body.isStatement()) {
+    listKey = "body";
+    key = 0;
+    statements.push(body.node);
+  } else {
+    stringPath += ".body.0";
+
+    if (this.isFunction()) {
+      key = "argument";
+      statements.push(returnStatement(body.node));
+    } else {
+      key = "expression";
+      statements.push(expressionStatement(body.node));
+    }
+  }
+
+  this.node.body = blockStatement(statements);
+  const parentPath = this.get(stringPath);
+  body.setup(parentPath, listKey ? parentPath.node[listKey] : parentPath.node, listKey, key);
+  return this.node;
+}
+
+function arrowFunctionToShadowed() {
+  if (!this.isArrowFunctionExpression()) return;
+  this.arrowFunctionToExpression();
+}
+
+function unwrapFunctionEnvironment() {
+  if (!this.isArrowFunctionExpression() && !this.isFunctionExpression() && !this.isFunctionDeclaration()) {
+    throw this.buildCodeFrameError("Can only unwrap the environment of a function.");
+  }
+
+  hoistFunctionEnvironment(this);
+}
+
+function arrowFunctionToExpression({
+  allowInsertArrow = true,
+  specCompliant = false,
+  noNewArrows = !specCompliant
+} = {}) {
+  if (!this.isArrowFunctionExpression()) {
+    throw this.buildCodeFrameError("Cannot convert non-arrow function to a function expression.");
+  }
+
+  const {
+    thisBinding,
+    fnPath: fn
+  } = hoistFunctionEnvironment(this, noNewArrows, allowInsertArrow);
+  fn.ensureBlock();
+  fn.node.type = "FunctionExpression";
+
+  if (!noNewArrows) {
+    const checkBinding = thisBinding ? null : fn.scope.generateUidIdentifier("arrowCheckId");
+
+    if (checkBinding) {
+      fn.parentPath.scope.push({
+        id: checkBinding,
+        init: objectExpression([])
+      });
+    }
+
+    fn.get("body").unshiftContainer("body", expressionStatement(callExpression(this.hub.addHelper("newArrowCheck"), [thisExpression(), checkBinding ? identifier(checkBinding.name) : identifier(thisBinding)])));
+    fn.replaceWith(callExpression(memberExpression((0, _helperFunctionName.default)(this, true) || fn.node, identifier("bind")), [checkBinding ? identifier(checkBinding.name) : thisExpression()]));
+  }
+}
+
+const getSuperCallsVisitor = (0, _visitors.merge)([{
+  CallExpression(child, {
+    allSuperCalls
+  }) {
+    if (!child.get("callee").isSuper()) return;
+    allSuperCalls.push(child);
+  }
+
+}, _helperEnvironmentVisitor.default]);
+
+function hoistFunctionEnvironment(fnPath, noNewArrows = true, allowInsertArrow = true) {
+  let arrowParent;
+  let thisEnvFn = fnPath.findParent(p => {
+    if (p.isArrowFunctionExpression()) {
+      var _arrowParent;
+
+      (_arrowParent = arrowParent) != null ? _arrowParent : arrowParent = p;
+      return false;
+    }
+
+    return p.isFunction() || p.isProgram() || p.isClassProperty({
+      static: false
+    }) || p.isClassPrivateProperty({
+      static: false
+    });
+  });
+  const inConstructor = thisEnvFn.isClassMethod({
+    kind: "constructor"
+  });
+
+  if (thisEnvFn.isClassProperty() || thisEnvFn.isClassPrivateProperty()) {
+    if (arrowParent) {
+      thisEnvFn = arrowParent;
+    } else if (allowInsertArrow) {
+      fnPath.replaceWith(callExpression(arrowFunctionExpression([], toExpression(fnPath.node)), []));
+      thisEnvFn = fnPath.get("callee");
+      fnPath = thisEnvFn.get("body");
+    } else {
+      throw fnPath.buildCodeFrameError("Unable to transform arrow inside class property");
+    }
+  }
+
+  const {
+    thisPaths,
+    argumentsPaths,
+    newTargetPaths,
+    superProps,
+    superCalls
+  } = getScopeInformation(fnPath);
+
+  if (inConstructor && superCalls.length > 0) {
+    if (!allowInsertArrow) {
+      throw superCalls[0].buildCodeFrameError("Unable to handle nested super() usage in arrow");
+    }
+
+    const allSuperCalls = [];
+    thisEnvFn.traverse(getSuperCallsVisitor, {
+      allSuperCalls
+    });
+    const superBinding = getSuperBinding(thisEnvFn);
+    allSuperCalls.forEach(superCall => {
+      const callee = identifier(superBinding);
+      callee.loc = superCall.node.callee.loc;
+      superCall.get("callee").replaceWith(callee);
+    });
+  }
+
+  if (argumentsPaths.length > 0) {
+    const argumentsBinding = getBinding(thisEnvFn, "arguments", () => {
+      const args = () => identifier("arguments");
+
+      if (thisEnvFn.scope.path.isProgram()) {
+        return conditionalExpression(binaryExpression("===", unaryExpression("typeof", args()), stringLiteral("undefined")), thisEnvFn.scope.buildUndefinedNode(), args());
+      } else {
+        return args();
+      }
+    });
+    argumentsPaths.forEach(argumentsChild => {
+      const argsRef = identifier(argumentsBinding);
+      argsRef.loc = argumentsChild.node.loc;
+      argumentsChild.replaceWith(argsRef);
+    });
+  }
+
+  if (newTargetPaths.length > 0) {
+    const newTargetBinding = getBinding(thisEnvFn, "newtarget", () => metaProperty(identifier("new"), identifier("target")));
+    newTargetPaths.forEach(targetChild => {
+      const targetRef = identifier(newTargetBinding);
+      targetRef.loc = targetChild.node.loc;
+      targetChild.replaceWith(targetRef);
+    });
+  }
+
+  if (superProps.length > 0) {
+    if (!allowInsertArrow) {
+      throw superProps[0].buildCodeFrameError("Unable to handle nested super.prop usage");
+    }
+
+    const flatSuperProps = superProps.reduce((acc, superProp) => acc.concat(standardizeSuperProperty(superProp)), []);
+    flatSuperProps.forEach(superProp => {
+      const key = superProp.node.computed ? "" : superProp.get("property").node.name;
+      const isAssignment = superProp.parentPath.isAssignmentExpression({
+        left: superProp.node
+      });
+      const isCall = superProp.parentPath.isCallExpression({
+        callee: superProp.node
+      });
+      const superBinding = getSuperPropBinding(thisEnvFn, isAssignment, key);
+      const args = [];
+
+      if (superProp.node.computed) {
+        args.push(superProp.get("property").node);
+      }
+
+      if (isAssignment) {
+        const value = superProp.parentPath.node.right;
+        args.push(value);
+      }
+
+      const call = callExpression(identifier(superBinding), args);
+
+      if (isCall) {
+        superProp.parentPath.unshiftContainer("arguments", thisExpression());
+        superProp.replaceWith(memberExpression(call, identifier("call")));
+        thisPaths.push(superProp.parentPath.get("arguments.0"));
+      } else if (isAssignment) {
+        superProp.parentPath.replaceWith(call);
+      } else {
+        superProp.replaceWith(call);
+      }
+    });
+  }
+
+  let thisBinding;
+
+  if (thisPaths.length > 0 || !noNewArrows) {
+    thisBinding = getThisBinding(thisEnvFn, inConstructor);
+
+    if (noNewArrows || inConstructor && hasSuperClass(thisEnvFn)) {
+      thisPaths.forEach(thisChild => {
+        const thisRef = thisChild.isJSX() ? jsxIdentifier(thisBinding) : identifier(thisBinding);
+        thisRef.loc = thisChild.node.loc;
+        thisChild.replaceWith(thisRef);
+      });
+      if (!noNewArrows) thisBinding = null;
+    }
+  }
+
+  return {
+    thisBinding,
+    fnPath
+  };
+}
+
+function isLogicalOp(op) {
+  return LOGICAL_OPERATORS.includes(op);
+}
+
+function standardizeSuperProperty(superProp) {
+  if (superProp.parentPath.isAssignmentExpression() && superProp.parentPath.node.operator !== "=") {
+    const assignmentPath = superProp.parentPath;
+    const op = assignmentPath.node.operator.slice(0, -1);
+    const value = assignmentPath.node.right;
+    const isLogicalAssignment = isLogicalOp(op);
+
+    if (superProp.node.computed) {
+      const tmp = superProp.scope.generateDeclaredUidIdentifier("tmp");
+      const object = superProp.node.object;
+      const property = superProp.node.property;
+      assignmentPath.get("left").replaceWith(memberExpression(object, assignmentExpression("=", tmp, property), true));
+      assignmentPath.get("right").replaceWith(rightExpression(isLogicalAssignment ? "=" : op, memberExpression(object, identifier(tmp.name), true), value));
+    } else {
+      const object = superProp.node.object;
+      const property = superProp.node.property;
+      assignmentPath.get("left").replaceWith(memberExpression(object, property));
+      assignmentPath.get("right").replaceWith(rightExpression(isLogicalAssignment ? "=" : op, memberExpression(object, identifier(property.name)), value));
+    }
+
+    if (isLogicalAssignment) {
+      assignmentPath.replaceWith(logicalExpression(op, assignmentPath.node.left, assignmentPath.node.right));
+    } else {
+      assignmentPath.node.operator = "=";
+    }
+
+    return [assignmentPath.get("left"), assignmentPath.get("right").get("left")];
+  } else if (superProp.parentPath.isUpdateExpression()) {
+    const updateExpr = superProp.parentPath;
+    const tmp = superProp.scope.generateDeclaredUidIdentifier("tmp");
+    const computedKey = superProp.node.computed ? superProp.scope.generateDeclaredUidIdentifier("prop") : null;
+    const parts = [assignmentExpression("=", tmp, memberExpression(superProp.node.object, computedKey ? assignmentExpression("=", computedKey, superProp.node.property) : superProp.node.property, superProp.node.computed)), assignmentExpression("=", memberExpression(superProp.node.object, computedKey ? identifier(computedKey.name) : superProp.node.property, superProp.node.computed), binaryExpression(superProp.parentPath.node.operator[0], identifier(tmp.name), numericLiteral(1)))];
+
+    if (!superProp.parentPath.node.prefix) {
+      parts.push(identifier(tmp.name));
+    }
+
+    updateExpr.replaceWith(sequenceExpression(parts));
+    const left = updateExpr.get("expressions.0.right");
+    const right = updateExpr.get("expressions.1.left");
+    return [left, right];
+  }
+
+  return [superProp];
+
+  function rightExpression(op, left, right) {
+    if (op === "=") {
+      return assignmentExpression("=", left, right);
+    } else {
+      return binaryExpression(op, left, right);
+    }
+  }
+}
+
+function hasSuperClass(thisEnvFn) {
+  return thisEnvFn.isClassMethod() && !!thisEnvFn.parentPath.parentPath.node.superClass;
+}
+
+const assignSuperThisVisitor = (0, _visitors.merge)([{
+  CallExpression(child, {
+    supers,
+    thisBinding
+  }) {
+    if (!child.get("callee").isSuper()) return;
+    if (supers.has(child.node)) return;
+    supers.add(child.node);
+    child.replaceWithMultiple([child.node, assignmentExpression("=", identifier(thisBinding), identifier("this"))]);
+  }
+
+}, _helperEnvironmentVisitor.default]);
+
+function getThisBinding(thisEnvFn, inConstructor) {
+  return getBinding(thisEnvFn, "this", thisBinding => {
+    if (!inConstructor || !hasSuperClass(thisEnvFn)) return thisExpression();
+    thisEnvFn.traverse(assignSuperThisVisitor, {
+      supers: new WeakSet(),
+      thisBinding
+    });
+  });
+}
+
+function getSuperBinding(thisEnvFn) {
+  return getBinding(thisEnvFn, "supercall", () => {
+    const argsBinding = thisEnvFn.scope.generateUidIdentifier("args");
+    return arrowFunctionExpression([restElement(argsBinding)], callExpression(_super(), [spreadElement(identifier(argsBinding.name))]));
+  });
+}
+
+function getSuperPropBinding(thisEnvFn, isAssignment, propName) {
+  const op = isAssignment ? "set" : "get";
+  return getBinding(thisEnvFn, `superprop_${op}:${propName || ""}`, () => {
+    const argsList = [];
+    let fnBody;
+
+    if (propName) {
+      fnBody = memberExpression(_super(), identifier(propName));
+    } else {
+      const method = thisEnvFn.scope.generateUidIdentifier("prop");
+      argsList.unshift(method);
+      fnBody = memberExpression(_super(), identifier(method.name), true);
+    }
+
+    if (isAssignment) {
+      const valueIdent = thisEnvFn.scope.generateUidIdentifier("value");
+      argsList.push(valueIdent);
+      fnBody = assignmentExpression("=", fnBody, identifier(valueIdent.name));
+    }
+
+    return arrowFunctionExpression(argsList, fnBody);
+  });
+}
+
+function getBinding(thisEnvFn, key, init) {
+  const cacheKey = "binding:" + key;
+  let data = thisEnvFn.getData(cacheKey);
+
+  if (!data) {
+    const id = thisEnvFn.scope.generateUidIdentifier(key);
+    data = id.name;
+    thisEnvFn.setData(cacheKey, data);
+    thisEnvFn.scope.push({
+      id: id,
+      init: init(data)
+    });
+  }
+
+  return data;
+}
+
+const getScopeInformationVisitor = (0, _visitors.merge)([{
+  ThisExpression(child, {
+    thisPaths
+  }) {
+    thisPaths.push(child);
+  },
+
+  JSXIdentifier(child, {
+    thisPaths
+  }) {
+    if (child.node.name !== "this") return;
+
+    if (!child.parentPath.isJSXMemberExpression({
+      object: child.node
+    }) && !child.parentPath.isJSXOpeningElement({
+      name: child.node
+    })) {
+      return;
+    }
+
+    thisPaths.push(child);
+  },
+
+  CallExpression(child, {
+    superCalls
+  }) {
+    if (child.get("callee").isSuper()) superCalls.push(child);
+  },
+
+  MemberExpression(child, {
+    superProps
+  }) {
+    if (child.get("object").isSuper()) superProps.push(child);
+  },
+
+  Identifier(child, {
+    argumentsPaths
+  }) {
+    if (!child.isReferencedIdentifier({
+      name: "arguments"
+    })) return;
+    let curr = child.scope;
+
+    do {
+      if (curr.hasOwnBinding("arguments")) {
+        curr.rename("arguments");
+        return;
+      }
+
+      if (curr.path.isFunction() && !curr.path.isArrowFunctionExpression()) {
+        break;
+      }
+    } while (curr = curr.parent);
+
+    argumentsPaths.push(child);
+  },
+
+  MetaProperty(child, {
+    newTargetPaths
+  }) {
+    if (!child.get("meta").isIdentifier({
+      name: "new"
+    })) return;
+    if (!child.get("property").isIdentifier({
+      name: "target"
+    })) return;
+    newTargetPaths.push(child);
+  }
+
+}, _helperEnvironmentVisitor.default]);
+
+function getScopeInformation(fnPath) {
+  const thisPaths = [];
+  const argumentsPaths = [];
+  const newTargetPaths = [];
+  const superProps = [];
+  const superCalls = [];
+  fnPath.traverse(getScopeInformationVisitor, {
+    thisPaths,
+    argumentsPaths,
+    newTargetPaths,
+    superProps,
+    superCalls
+  });
+  return {
+    thisPaths,
+    argumentsPaths,
+    newTargetPaths,
+    superProps,
+    superCalls
+  };
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/traverse/lib/path/evaluation.js

@@ -0,0 +1,401 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.evaluate = evaluate;
+exports.evaluateTruthy = evaluateTruthy;
+const VALID_CALLEES = ["String", "Number", "Math"];
+const INVALID_METHODS = ["random"];
+
+function evaluateTruthy() {
+  const res = this.evaluate();
+  if (res.confident) return !!res.value;
+}
+
+function deopt(path, state) {
+  if (!state.confident) return;
+  state.deoptPath = path;
+  state.confident = false;
+}
+
+function evaluateCached(path, state) {
+  const {
+    node
+  } = path;
+  const {
+    seen
+  } = state;
+
+  if (seen.has(node)) {
+    const existing = seen.get(node);
+
+    if (existing.resolved) {
+      return existing.value;
+    } else {
+      deopt(path, state);
+      return;
+    }
+  } else {
+    const item = {
+      resolved: false
+    };
+    seen.set(node, item);
+
+    const val = _evaluate(path, state);
+
+    if (state.confident) {
+      item.resolved = true;
+      item.value = val;
+    }
+
+    return val;
+  }
+}
+
+function _evaluate(path, state) {
+  if (!state.confident) return;
+
+  if (path.isSequenceExpression()) {
+    const exprs = path.get("expressions");
+    return evaluateCached(exprs[exprs.length - 1], state);
+  }
+
+  if (path.isStringLiteral() || path.isNumericLiteral() || path.isBooleanLiteral()) {
+    return path.node.value;
+  }
+
+  if (path.isNullLiteral()) {
+    return null;
+  }
+
+  if (path.isTemplateLiteral()) {
+    return evaluateQuasis(path, path.node.quasis, state);
+  }
+
+  if (path.isTaggedTemplateExpression() && path.get("tag").isMemberExpression()) {
+    const object = path.get("tag.object");
+    const {
+      node: {
+        name
+      }
+    } = object;
+    const property = path.get("tag.property");
+
+    if (object.isIdentifier() && name === "String" && !path.scope.getBinding(name) && property.isIdentifier() && property.node.name === "raw") {
+      return evaluateQuasis(path, path.node.quasi.quasis, state, true);
+    }
+  }
+
+  if (path.isConditionalExpression()) {
+    const testResult = evaluateCached(path.get("test"), state);
+    if (!state.confident) return;
+
+    if (testResult) {
+      return evaluateCached(path.get("consequent"), state);
+    } else {
+      return evaluateCached(path.get("alternate"), state);
+    }
+  }
+
+  if (path.isExpressionWrapper()) {
+    return evaluateCached(path.get("expression"), state);
+  }
+
+  if (path.isMemberExpression() && !path.parentPath.isCallExpression({
+    callee: path.node
+  })) {
+    const property = path.get("property");
+    const object = path.get("object");
+
+    if (object.isLiteral() && property.isIdentifier()) {
+      const value = object.node.value;
+      const type = typeof value;
+
+      if (type === "number" || type === "string") {
+        return value[property.node.name];
+      }
+    }
+  }
+
+  if (path.isReferencedIdentifier()) {
+    const binding = path.scope.getBinding(path.node.name);
+
+    if (binding && binding.constantViolations.length > 0) {
+      return deopt(binding.path, state);
+    }
+
+    if (binding && path.node.start < binding.path.node.end) {
+      return deopt(binding.path, state);
+    }
+
+    if (binding != null && binding.hasValue) {
+      return binding.value;
+    } else {
+      if (path.node.name === "undefined") {
+        return binding ? deopt(binding.path, state) : undefined;
+      } else if (path.node.name === "Infinity") {
+        return binding ? deopt(binding.path, state) : Infinity;
+      } else if (path.node.name === "NaN") {
+        return binding ? deopt(binding.path, state) : NaN;
+      }
+
+      const resolved = path.resolve();
+
+      if (resolved === path) {
+        return deopt(path, state);
+      } else {
+        return evaluateCached(resolved, state);
+      }
+    }
+  }
+
+  if (path.isUnaryExpression({
+    prefix: true
+  })) {
+    if (path.node.operator === "void") {
+      return undefined;
+    }
+
+    const argument = path.get("argument");
+
+    if (path.node.operator === "typeof" && (argument.isFunction() || argument.isClass())) {
+      return "function";
+    }
+
+    const arg = evaluateCached(argument, state);
+    if (!state.confident) return;
+
+    switch (path.node.operator) {
+      case "!":
+        return !arg;
+
+      case "+":
+        return +arg;
+
+      case "-":
+        return -arg;
+
+      case "~":
+        return ~arg;
+
+      case "typeof":
+        return typeof arg;
+    }
+  }
+
+  if (path.isArrayExpression()) {
+    const arr = [];
+    const elems = path.get("elements");
+
+    for (const elem of elems) {
+      const elemValue = elem.evaluate();
+
+      if (elemValue.confident) {
+        arr.push(elemValue.value);
+      } else {
+        return deopt(elemValue.deopt, state);
+      }
+    }
+
+    return arr;
+  }
+
+  if (path.isObjectExpression()) {
+    const obj = {};
+    const props = path.get("properties");
+
+    for (const prop of props) {
+      if (prop.isObjectMethod() || prop.isSpreadElement()) {
+        return deopt(prop, state);
+      }
+
+      const keyPath = prop.get("key");
+      let key = keyPath;
+
+      if (prop.node.computed) {
+        key = key.evaluate();
+
+        if (!key.confident) {
+          return deopt(key.deopt, state);
+        }
+
+        key = key.value;
+      } else if (key.isIdentifier()) {
+        key = key.node.name;
+      } else {
+        key = key.node.value;
+      }
+
+      const valuePath = prop.get("value");
+      let value = valuePath.evaluate();
+
+      if (!value.confident) {
+        return deopt(value.deopt, state);
+      }
+
+      value = value.value;
+      obj[key] = value;
+    }
+
+    return obj;
+  }
+
+  if (path.isLogicalExpression()) {
+    const wasConfident = state.confident;
+    const left = evaluateCached(path.get("left"), state);
+    const leftConfident = state.confident;
+    state.confident = wasConfident;
+    const right = evaluateCached(path.get("right"), state);
+    const rightConfident = state.confident;
+
+    switch (path.node.operator) {
+      case "||":
+        state.confident = leftConfident && (!!left || rightConfident);
+        if (!state.confident) return;
+        return left || right;
+
+      case "&&":
+        state.confident = leftConfident && (!left || rightConfident);
+        if (!state.confident) return;
+        return left && right;
+    }
+  }
+
+  if (path.isBinaryExpression()) {
+    const left = evaluateCached(path.get("left"), state);
+    if (!state.confident) return;
+    const right = evaluateCached(path.get("right"), state);
+    if (!state.confident) return;
+
+    switch (path.node.operator) {
+      case "-":
+        return left - right;
+
+      case "+":
+        return left + right;
+
+      case "/":
+        return left / right;
+
+      case "*":
+        return left * right;
+
+      case "%":
+        return left % right;
+
+      case "**":
+        return Math.pow(left, right);
+
+      case "<":
+        return left < right;
+
+      case ">":
+        return left > right;
+
+      case "<=":
+        return left <= right;
+
+      case ">=":
+        return left >= right;
+
+      case "==":
+        return left == right;
+
+      case "!=":
+        return left != right;
+
+      case "===":
+        return left === right;
+
+      case "!==":
+        return left !== right;
+
+      case "|":
+        return left | right;
+
+      case "&":
+        return left & right;
+
+      case "^":
+        return left ^ right;
+
+      case "<<":
+        return left << right;
+
+      case ">>":
+        return left >> right;
+
+      case ">>>":
+        return left >>> right;
+    }
+  }
+
+  if (path.isCallExpression()) {
+    const callee = path.get("callee");
+    let context;
+    let func;
+
+    if (callee.isIdentifier() && !path.scope.getBinding(callee.node.name) && VALID_CALLEES.indexOf(callee.node.name) >= 0) {
+      func = global[callee.node.name];
+    }
+
+    if (callee.isMemberExpression()) {
+      const object = callee.get("object");
+      const property = callee.get("property");
+
+      if (object.isIdentifier() && property.isIdentifier() && VALID_CALLEES.indexOf(object.node.name) >= 0 && INVALID_METHODS.indexOf(property.node.name) < 0) {
+        context = global[object.node.name];
+        func = context[property.node.name];
+      }
+
+      if (object.isLiteral() && property.isIdentifier()) {
+        const type = typeof object.node.value;
+
+        if (type === "string" || type === "number") {
+          context = object.node.value;
+          func = context[property.node.name];
+        }
+      }
+    }
+
+    if (func) {
+      const args = path.get("arguments").map(arg => evaluateCached(arg, state));
+      if (!state.confident) return;
+      return func.apply(context, args);
+    }
+  }
+
+  deopt(path, state);
+}
+
+function evaluateQuasis(path, quasis, state, raw = false) {
+  let str = "";
+  let i = 0;
+  const exprs = path.get("expressions");
+
+  for (const elem of quasis) {
+    if (!state.confident) break;
+    str += raw ? elem.value.raw : elem.value.cooked;
+    const expr = exprs[i++];
+    if (expr) str += String(evaluateCached(expr, state));
+  }
+
+  if (!state.confident) return;
+  return str;
+}
+
+function evaluate() {
+  const state = {
+    confident: true,
+    deoptPath: null,
+    seen: new Map()
+  };
+  let value = evaluateCached(this, state);
+  if (!state.confident) value = undefined;
+  return {
+    confident: state.confident,
+    deopt: state.deoptPath,
+    value: value
+  };
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/traverse/lib/path/family.js

@@ -0,0 +1,407 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports._getKey = _getKey;
+exports._getPattern = _getPattern;
+exports.get = get;
+exports.getAllNextSiblings = getAllNextSiblings;
+exports.getAllPrevSiblings = getAllPrevSiblings;
+exports.getBindingIdentifierPaths = getBindingIdentifierPaths;
+exports.getBindingIdentifiers = getBindingIdentifiers;
+exports.getCompletionRecords = getCompletionRecords;
+exports.getNextSibling = getNextSibling;
+exports.getOpposite = getOpposite;
+exports.getOuterBindingIdentifierPaths = getOuterBindingIdentifierPaths;
+exports.getOuterBindingIdentifiers = getOuterBindingIdentifiers;
+exports.getPrevSibling = getPrevSibling;
+exports.getSibling = getSibling;
+
+var _index = require("./index");
+
+var _t = require("@babel/types");
+
+const {
+  getBindingIdentifiers: _getBindingIdentifiers,
+  getOuterBindingIdentifiers: _getOuterBindingIdentifiers,
+  isDeclaration,
+  numericLiteral,
+  unaryExpression
+} = _t;
+const NORMAL_COMPLETION = 0;
+const BREAK_COMPLETION = 1;
+
+function NormalCompletion(path) {
+  return {
+    type: NORMAL_COMPLETION,
+    path
+  };
+}
+
+function BreakCompletion(path) {
+  return {
+    type: BREAK_COMPLETION,
+    path
+  };
+}
+
+function getOpposite() {
+  if (this.key === "left") {
+    return this.getSibling("right");
+  } else if (this.key === "right") {
+    return this.getSibling("left");
+  }
+
+  return null;
+}
+
+function addCompletionRecords(path, records, context) {
+  if (path) {
+    records.push(..._getCompletionRecords(path, context));
+  }
+
+  return records;
+}
+
+function completionRecordForSwitch(cases, records, context) {
+  let lastNormalCompletions = [];
+
+  for (let i = 0; i < cases.length; i++) {
+    const casePath = cases[i];
+
+    const caseCompletions = _getCompletionRecords(casePath, context);
+
+    const normalCompletions = [];
+    const breakCompletions = [];
+
+    for (const c of caseCompletions) {
+      if (c.type === NORMAL_COMPLETION) {
+        normalCompletions.push(c);
+      }
+
+      if (c.type === BREAK_COMPLETION) {
+        breakCompletions.push(c);
+      }
+    }
+
+    if (normalCompletions.length) {
+      lastNormalCompletions = normalCompletions;
+    }
+
+    records.push(...breakCompletions);
+  }
+
+  records.push(...lastNormalCompletions);
+  return records;
+}
+
+function normalCompletionToBreak(completions) {
+  completions.forEach(c => {
+    c.type = BREAK_COMPLETION;
+  });
+}
+
+function replaceBreakStatementInBreakCompletion(completions, reachable) {
+  completions.forEach(c => {
+    if (c.path.isBreakStatement({
+      label: null
+    })) {
+      if (reachable) {
+        c.path.replaceWith(unaryExpression("void", numericLiteral(0)));
+      } else {
+        c.path.remove();
+      }
+    }
+  });
+}
+
+function getStatementListCompletion(paths, context) {
+  const completions = [];
+
+  if (context.canHaveBreak) {
+    let lastNormalCompletions = [];
+
+    for (let i = 0; i < paths.length; i++) {
+      const path = paths[i];
+      const newContext = Object.assign({}, context, {
+        inCaseClause: false
+      });
+
+      if (path.isBlockStatement() && (context.inCaseClause || context.shouldPopulateBreak)) {
+        newContext.shouldPopulateBreak = true;
+      } else {
+        newContext.shouldPopulateBreak = false;
+      }
+
+      const statementCompletions = _getCompletionRecords(path, newContext);
+
+      if (statementCompletions.length > 0 && statementCompletions.every(c => c.type === BREAK_COMPLETION)) {
+        if (lastNormalCompletions.length > 0 && statementCompletions.every(c => c.path.isBreakStatement({
+          label: null
+        }))) {
+          normalCompletionToBreak(lastNormalCompletions);
+          completions.push(...lastNormalCompletions);
+
+          if (lastNormalCompletions.some(c => c.path.isDeclaration())) {
+            completions.push(...statementCompletions);
+            replaceBreakStatementInBreakCompletion(statementCompletions, true);
+          }
+
+          replaceBreakStatementInBreakCompletion(statementCompletions, false);
+        } else {
+          completions.push(...statementCompletions);
+
+          if (!context.shouldPopulateBreak) {
+            replaceBreakStatementInBreakCompletion(statementCompletions, true);
+          }
+        }
+
+        break;
+      }
+
+      if (i === paths.length - 1) {
+        completions.push(...statementCompletions);
+      } else {
+        lastNormalCompletions = [];
+
+        for (let i = 0; i < statementCompletions.length; i++) {
+          const c = statementCompletions[i];
+
+          if (c.type === BREAK_COMPLETION) {
+            completions.push(c);
+          }
+
+          if (c.type === NORMAL_COMPLETION) {
+            lastNormalCompletions.push(c);
+          }
+        }
+      }
+    }
+  } else if (paths.length) {
+    for (let i = paths.length - 1; i >= 0; i--) {
+      const pathCompletions = _getCompletionRecords(paths[i], context);
+
+      if (pathCompletions.length > 1 || pathCompletions.length === 1 && !pathCompletions[0].path.isVariableDeclaration()) {
+        completions.push(...pathCompletions);
+        break;
+      }
+    }
+  }
+
+  return completions;
+}
+
+function _getCompletionRecords(path, context) {
+  let records = [];
+
+  if (path.isIfStatement()) {
+    records = addCompletionRecords(path.get("consequent"), records, context);
+    records = addCompletionRecords(path.get("alternate"), records, context);
+  } else if (path.isDoExpression() || path.isFor() || path.isWhile() || path.isLabeledStatement()) {
+    return addCompletionRecords(path.get("body"), records, context);
+  } else if (path.isProgram() || path.isBlockStatement()) {
+    return getStatementListCompletion(path.get("body"), context);
+  } else if (path.isFunction()) {
+    return _getCompletionRecords(path.get("body"), context);
+  } else if (path.isTryStatement()) {
+    records = addCompletionRecords(path.get("block"), records, context);
+    records = addCompletionRecords(path.get("handler"), records, context);
+  } else if (path.isCatchClause()) {
+    return addCompletionRecords(path.get("body"), records, context);
+  } else if (path.isSwitchStatement()) {
+    return completionRecordForSwitch(path.get("cases"), records, context);
+  } else if (path.isSwitchCase()) {
+    return getStatementListCompletion(path.get("consequent"), {
+      canHaveBreak: true,
+      shouldPopulateBreak: false,
+      inCaseClause: true
+    });
+  } else if (path.isBreakStatement()) {
+    records.push(BreakCompletion(path));
+  } else {
+    records.push(NormalCompletion(path));
+  }
+
+  return records;
+}
+
+function getCompletionRecords() {
+  const records = _getCompletionRecords(this, {
+    canHaveBreak: false,
+    shouldPopulateBreak: false,
+    inCaseClause: false
+  });
+
+  return records.map(r => r.path);
+}
+
+function getSibling(key) {
+  return _index.default.get({
+    parentPath: this.parentPath,
+    parent: this.parent,
+    container: this.container,
+    listKey: this.listKey,
+    key: key
+  }).setContext(this.context);
+}
+
+function getPrevSibling() {
+  return this.getSibling(this.key - 1);
+}
+
+function getNextSibling() {
+  return this.getSibling(this.key + 1);
+}
+
+function getAllNextSiblings() {
+  let _key = this.key;
+  let sibling = this.getSibling(++_key);
+  const siblings = [];
+
+  while (sibling.node) {
+    siblings.push(sibling);
+    sibling = this.getSibling(++_key);
+  }
+
+  return siblings;
+}
+
+function getAllPrevSiblings() {
+  let _key = this.key;
+  let sibling = this.getSibling(--_key);
+  const siblings = [];
+
+  while (sibling.node) {
+    siblings.push(sibling);
+    sibling = this.getSibling(--_key);
+  }
+
+  return siblings;
+}
+
+function get(key, context = true) {
+  if (context === true) context = this.context;
+  const parts = key.split(".");
+
+  if (parts.length === 1) {
+    return this._getKey(key, context);
+  } else {
+    return this._getPattern(parts, context);
+  }
+}
+
+function _getKey(key, context) {
+  const node = this.node;
+  const container = node[key];
+
+  if (Array.isArray(container)) {
+    return container.map((_, i) => {
+      return _index.default.get({
+        listKey: key,
+        parentPath: this,
+        parent: node,
+        container: container,
+        key: i
+      }).setContext(context);
+    });
+  } else {
+    return _index.default.get({
+      parentPath: this,
+      parent: node,
+      container: node,
+      key: key
+    }).setContext(context);
+  }
+}
+
+function _getPattern(parts, context) {
+  let path = this;
+
+  for (const part of parts) {
+    if (part === ".") {
+      path = path.parentPath;
+    } else {
+      if (Array.isArray(path)) {
+        path = path[part];
+      } else {
+        path = path.get(part, context);
+      }
+    }
+  }
+
+  return path;
+}
+
+function getBindingIdentifiers(duplicates) {
+  return _getBindingIdentifiers(this.node, duplicates);
+}
+
+function getOuterBindingIdentifiers(duplicates) {
+  return _getOuterBindingIdentifiers(this.node, duplicates);
+}
+
+function getBindingIdentifierPaths(duplicates = false, outerOnly = false) {
+  const path = this;
+  const search = [path];
+  const ids = Object.create(null);
+
+  while (search.length) {
+    const id = search.shift();
+    if (!id) continue;
+    if (!id.node) continue;
+    const keys = _getBindingIdentifiers.keys[id.node.type];
+
+    if (id.isIdentifier()) {
+      if (duplicates) {
+        const _ids = ids[id.node.name] = ids[id.node.name] || [];
+
+        _ids.push(id);
+      } else {
+        ids[id.node.name] = id;
+      }
+
+      continue;
+    }
+
+    if (id.isExportDeclaration()) {
+      const declaration = id.get("declaration");
+
+      if (isDeclaration(declaration)) {
+        search.push(declaration);
+      }
+
+      continue;
+    }
+
+    if (outerOnly) {
+      if (id.isFunctionDeclaration()) {
+        search.push(id.get("id"));
+        continue;
+      }
+
+      if (id.isFunctionExpression()) {
+        continue;
+      }
+    }
+
+    if (keys) {
+      for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const child = id.get(key);
+
+        if (Array.isArray(child)) {
+          search.push(...child);
+        } else if (child.node) {
+          search.push(child);
+        }
+      }
+    }
+  }
+
+  return ids;
+}
+
+function getOuterBindingIdentifierPaths(duplicates) {
+  return this.getBindingIdentifierPaths(duplicates, true);
+}

node_modules/light-bolt11-decoder/examples/node_modules/@babel/traverse/lib/path/generated/asserts.js

@@ -0,0 +1,5 @@
+"use strict";
+
+var t = require("@babel/types");
+
+var _index = require("../index");