picata 0.0.6__py3-none-any.whl → 0.0.8__py3-none-any.whl

node_modules/colorette/LICENSE.md

@@ -0,0 +1,7 @@
+Copyright © Jorge Bucaran <<https://jorgebucaran.com>>
+
+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/colorette/README.md

@@ -0,0 +1,134 @@
+# 🌈Colorette
+
+> Easily set your terminal text color & styles.
+
+- No dependecies
+- Automatic color support detection
+- Up to [2x faster](#benchmarks) than alternatives
+- TypeScript support
+- [`NO_COLOR`](https://no-color.org) friendly
+- Node >= `10`
+
+> [**Upgrading from Colorette `1.x`?**](https://github.com/jorgebucaran/colorette/issues/70)
+
+## Quickstart
+
+```js
+import { blue, bold, underline } from "colorette"
+
+console.log(
+  blue("I'm blue"),
+  bold(blue("da ba dee")),
+  underline(bold(blue("da ba daa")))
+)
+```
+
+Here's an example using [template literals](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals).
+
+```js
+console.log(`
+  There's a ${underline(blue("house"))},
+  With a ${bold(blue("window"))},
+  And a ${blue("corvette")}
+  And everything is blue
+`)
+```
+
+You can also nest styles without breaking existing color sequences.
+
+```js
+console.log(bold(`I'm ${blue(`da ba ${underline("dee")} da ba`)} daa`))
+```
+
+Need to override terminal color detection? You can do that too.
+
+```js
+import { createColors } from "colorette"
+
+const { blue } = createColors({ useColor: false })
+
+console.log(blue("Blue? Nope, nah"))
+```
+
+## Installation
+
+```console
+npm install colorette
+```
+
+## API
+
+### \<color\>()
+
+> See all [supported colors](#supported-colors).
+
+```js
+import { blue } from "colorette"
+
+blue("I'm blue") //=> \x1b[34mI'm blue\x1b[39m
+```
+
+### createColors()
+
+Override terminal color detection via `createColors({ useColor })`.
+
+```js
+import { createColors } from "colorette"
+
+const { blue } = createColors({ useColor: false })
+```
+
+### isColorSupported
+
+`true` if your terminal supports color, `false` otherwise. Used internally, but exposed for convenience.
+
+## Environment
+
+You can override color detection from the CLI by setting the `--no-color` or `--color` flags.
+
+```console
+$ ./example.js --no-color | ./consumer.js
+```
+
+Or if you can't use CLI flags, by setting the `NO_COLOR=` or `FORCE_COLOR=` environment variables.
+
+```console
+$ NO_COLOR= ./example.js | ./consumer.js
+```
+
+## Supported colors
+
+| Colors  | Background Colors | Bright Colors | Bright Background Colors | Modifiers         |
+| ------- | ----------------- | ------------- | ------------------------ | ----------------- |
+| black   | bgBlack           | blackBright   | bgBlackBright            | dim               |
+| red     | bgRed             | redBright     | bgRedBright              | **bold**          |
+| green   | bgGreen           | greenBright   | bgGreenBright            | hidden            |
+| yellow  | bgYellow          | yellowBright  | bgYellowBright           | _italic_          |
+| blue    | bgBlue            | blueBright    | bgBlueBright             | <u>underline</u>  |
+| magenta | bgMagenta         | magentaBright | bgMagentaBright          | ~~strikethrough~~ |
+| cyan    | bgCyan            | cyanBright    | bgCyanBright             | reset             |
+| white   | bgWhite           | whiteBright   | bgWhiteBright            |                   |
+| gray    |                   |               |                          |                   |
+
+## [Benchmarks](https://github.com/jorgebucaran/colorette/actions/workflows/bench.yml)
+
+```console
+npm --prefix bench start
+```
+
+```diff
+  chalk         1,786,703 ops/sec
+  kleur         1,618,960 ops/sec
+  colors          646,823 ops/sec
+  ansi-colors     786,149 ops/sec
+  picocolors    2,871,758 ops/sec
++ colorette     3,002,751 ops/sec
+```
+
+## Acknowledgments
+
+Colorette started out in 2015 by [@jorgebucaran](https://github.com/jorgebucaran) as a lightweight alternative to [Chalk](https://github.com/chalk/chalk) and was introduced originally as [Clor](https://github.com/jorgebucaran/colorette/commit/b01b5b9961ceb7df878583a3002e836fae9e37ce). Our terminal color detection logic borrows heavily from [@sindresorhus](https://github.com/sindresorhus) and [@Qix-](https://github.com/Qix-) work on Chalk. The idea of slicing strings to clear bleeding sequences was adapted from a similar technique used by [@alexeyraspopov](https://github.com/alexeyraspopov) in [picocolors](https://github.com/alexeyraspopov/picocolors). Thank you to all our contributors! <3
+
+## License
+
+[MIT](LICENSE.md)

node_modules/common-path-prefix/README.md

@@ -0,0 +1,51 @@
+# common-path-prefix
+
+Computes the longest prefix string that is common to each path, excluding the base component. Tested with Node.js 8 and above.
+
+## Installation
+
+```console
+npm install common-path-prefix
+```
+
+## Usage
+
+The module has one default export, the `commonPathPrefix` function:
+
+```js
+const commonPathPrefix = require('common-path-prefix')
+```
+
+Call `commonPathPrefix()` with an array of paths (strings) and an optional separator character:
+
+```js
+const paths = ['templates/main.handlebars', 'templates/_partial.handlebars']
+
+commonPathPrefix(paths, '/') // returns 'templates/'
+```
+
+If the separator is not provided the first `/` or `\` found in any of the paths is used. Otherwise the platform-default value is used:
+
+```js
+commonPathPrefix(['templates/main.handlebars', 'templates/_partial.handlebars']) // returns 'templates/'
+commonPathPrefix(['templates\\main.handlebars', 'templates\\_partial.handlebars']) // returns 'templates\\'
+```
+
+You can provide any separator, for example:
+
+```js
+commonPathPrefix(['foo$bar', 'foo$baz'], '$') // returns 'foo$''
+```
+
+An empty string is returned if no common prefix exists:
+
+```js
+commonPathPrefix(['foo/bar', 'baz/qux']) // returns ''
+commonPathPrefix(['foo/bar']) // returns ''
+```
+
+Note that the following *does* have a common prefix:
+
+```js
+commonPathPrefix(['/foo/bar', '/baz/qux']) // returns '/'
+```

node_modules/concurrently/README.md

@@ -0,0 +1,229 @@
+# concurrently
+
+[![Latest Release](https://img.shields.io/github/v/release/open-cli-tools/concurrently?label=Release)](https://github.com/open-cli-tools/concurrently/releases)
+[![License](https://img.shields.io/github/license/open-cli-tools/concurrently?label=License)](https://github.com/open-cli-tools/concurrently/blob/main/LICENSE)
+[![Weekly Downloads on NPM](https://img.shields.io/npm/dw/concurrently?label=Downloads&logo=npm)](https://www.npmjs.com/package/concurrently)
+[![CI Status](https://img.shields.io/github/actions/workflow/status/open-cli-tools/concurrently/test.yml?label=CI&logo=github)](https://github.com/open-cli-tools/concurrently/actions/workflows/test.yml)
+[![Coverage Status](https://img.shields.io/coveralls/github/open-cli-tools/concurrently/main?label=Coverage&logo=coveralls)](https://coveralls.io/github/open-cli-tools/concurrently?branch=main)
+
+Run multiple commands concurrently.
+Like `npm run watch-js & npm run watch-less` but better.
+
+![Demo](docs/demo.gif)
+
+**Table of Contents**
+
+- [concurrently](#concurrently)
+  - [Why](#why)
+  - [Installation](#installation)
+  - [Usage](#usage)
+  - [API](#api)
+    - [`concurrently(commands[, options])`](#concurrentlycommands-options)
+    - [`Command`](#command)
+    - [`CloseEvent`](#closeevent)
+  - [FAQ](#faq)
+
+## Why
+
+I like [task automation with npm](https://web.archive.org/web/20220531064025/https://github.com/substack/blog/blob/master/npm_run.markdown)
+but the usual way to run multiple commands concurrently is
+`npm run watch-js & npm run watch-css`. That's fine but it's hard to keep
+on track of different outputs. Also if one process fails, others still keep running
+and you won't even notice the difference.
+
+Another option would be to just run all commands in separate terminals. I got
+tired of opening terminals and made **concurrently**.
+
+**Features:**
+
+- Cross platform (including Windows)
+- Output is easy to follow with prefixes
+- With `--kill-others` switch, all commands are killed if one dies
+
+## Installation
+
+**concurrently** can be installed in the global scope (if you'd like to have it available and use it on the whole system) or locally for a specific package (for example if you'd like to use it in the `scripts` section of your package):
+
+|             | npm                     | Yarn                           | pnpm                       | Bun                       |
+| ----------- | ----------------------- | ------------------------------ | -------------------------- | ------------------------- |
+| **Global**  | `npm i -g concurrently` | `yarn global add concurrently` | `pnpm add -g concurrently` | `bun add -g concurrently` |
+| **Local**\* | `npm i -D concurrently` | `yarn add -D concurrently`     | `pnpm add -D concurrently` | `bun add -d concurrently` |
+
+<sub>\* It's recommended to add **concurrently** to `devDependencies` as it's usually used for developing purposes. Please adjust the command if this doesn't apply in your case.</sub>
+
+## Usage
+
+> **Note**
+> The `concurrently` command is also available under the shorthand alias `conc`.
+
+The tool is written in Node.js, but you can use it to run **any** commands.
+
+Remember to surround separate commands with quotes:
+
+```bash
+concurrently "command1 arg" "command2 arg"
+```
+
+Otherwise **concurrently** would try to run 4 separate commands:
+`command1`, `arg`, `command2`, `arg`.
+
+In package.json, escape quotes:
+
+```bash
+"start": "concurrently \"command1 arg\" \"command2 arg\""
+```
+
+You can always check concurrently's flag list by running `concurrently --help`.
+For the version, run `concurrently --version`.
+
+Check out documentation and other usage examples in the [`docs` directory](./docs/README.md).
+
+## API
+
+**concurrently** can be used programmatically by using the API documented below:
+
+### `concurrently(commands[, options])`
+
+- `commands`: an array of either strings (containing the commands to run) or objects
+  with the shape `{ command, name, prefixColor, env, cwd, ipc }`.
+
+- `options` (optional): an object containing any of the below:
+  - `cwd`: the working directory to be used by all commands. Can be overriden per command.
+    Default: `process.cwd()`.
+  - `defaultInputTarget`: the default input target when reading from `inputStream`.
+    Default: `0`.
+  - `handleInput`: when `true`, reads input from `process.stdin`.
+  - `inputStream`: a [`Readable` stream](https://nodejs.org/dist/latest-v10.x/docs/api/stream.html#stream_readable_streams)
+    to read the input from. Should only be used in the rare instance you would like to stream anything other than `process.stdin`. Overrides `handleInput`.
+  - `pauseInputStreamOnFinish`: by default, pauses the input stream (`process.stdin` when `handleInput` is enabled, or `inputStream` if provided) when all of the processes have finished. If you need to read from the input stream after `concurrently` has finished, set this to `false`. ([#252](https://github.com/kimmobrunfeldt/concurrently/issues/252)).
+  - `killOthers`: an array of exitting conditions that will cause a process to kill others.
+    Can contain any of `success` or `failure`.
+  - `maxProcesses`: how many processes should run at once.
+  - `outputStream`: a [`Writable` stream](https://nodejs.org/dist/latest-v10.x/docs/api/stream.html#stream_writable_streams)
+    to write logs to. Default: `process.stdout`.
+  - `prefix`: the prefix type to use when logging processes output.
+    Possible values: `index`, `pid`, `time`, `command`, `name`, `none`, or a template (eg `[{time} process: {pid}]`).
+    Default: the name of the process, or its index if no name is set.
+  - `prefixColors`: a list of colors or a string as supported by [chalk](https://www.npmjs.com/package/chalk) and additional style `auto` for an automatically picked color.
+    If concurrently would run more commands than there are colors, the last color is repeated, unless if the last color value is `auto` which means following colors are automatically picked to vary.
+    Prefix colors specified per-command take precedence over this list.
+  - `prefixLength`: how many characters to show when prefixing with `command`. Default: `10`
+  - `raw`: whether raw mode should be used, meaning strictly process output will
+    be logged, without any prefixes, coloring or extra stuff. Can be overriden per command.
+  - `successCondition`: the condition to consider the run was successful.
+    If `first`, only the first process to exit will make up the success of the run; if `last`, the last process that exits will determine whether the run succeeds.
+    Anything else means all processes should exit successfully.
+  - `restartTries`: how many attempts to restart a process that dies will be made. Default: `0`.
+  - `restartDelay`: how many milliseconds to wait between process restarts. Default: `0`.
+  - `timestampFormat`: a [Unicode format](https://www.unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table)
+    to use when prefixing with `time`. Default: `yyyy-MM-dd HH:mm:ss.ZZZ`
+  - `additionalArguments`: list of additional arguments passed that will get replaced in each command. If not defined, no argument replacing will happen.
+
+> **Returns:** an object in the shape `{ result, commands }`.
+>
+> - `result`: a `Promise` that resolves if the run was successful (according to `successCondition` option),
+>   or rejects, containing an array of [`CloseEvent`](#CloseEvent), in the order that the commands terminated.
+> - `commands`: an array of all spawned [`Command`s](#Command).
+
+Example:
+
+```js
+const concurrently = require('concurrently');
+const { result } = concurrently(
+  [
+    'npm:watch-*',
+    { command: 'nodemon', name: 'server' },
+    { command: 'deploy', name: 'deploy', env: { PUBLIC_KEY: '...' } },
+    {
+      command: 'watch',
+      name: 'watch',
+      cwd: path.resolve(__dirname, 'scripts/watchers'),
+    },
+  ],
+  {
+    prefix: 'name',
+    killOthers: ['failure', 'success'],
+    restartTries: 3,
+    cwd: path.resolve(__dirname, 'scripts'),
+  },
+);
+result.then(success, failure);
+```
+
+### `Command`
+
+An object that contains all information about a spawned command, and ways to interact with it.<br>
+It has the following properties:
+
+- `index`: the index of the command among all commands spawned.
+- `command`: the command line of the command.
+- `name`: the name of the command; defaults to an empty string.
+- `cwd`: the current working directory of the command.
+- `env`: an object with all the environment variables that the command will be spawned with.
+- `killed`: whether the command has been killed.
+- `state`: the command's state. Can be one of
+  - `stopped`: if the command was never started
+  - `started`: if the command is currently running
+  - `errored`: if the command failed spawning
+  - `exited`: if the command is not running anymore, e.g. it received a close event
+- `pid`: the command's process ID.
+- `stdin`: a Writable stream to the command's `stdin`.
+- `stdout`: an RxJS observable to the command's `stdout`.
+- `stderr`: an RxJS observable to the command's `stderr`.
+- `error`: an RxJS observable to the command's error events (e.g. when it fails to spawn).
+- `timer`: an RxJS observable to the command's timing events (e.g. starting, stopping).
+- `messages`: an object with the following properties:
+
+  - `incoming`: an RxJS observable for the IPC messages received from the underlying process.
+  - `outgoing`: an RxJS observable for the IPC messages sent to the underlying process.
+
+  Both observables emit [`MessageEvent`](#messageevent)s.<br>
+  Note that if the command wasn't spawned with IPC support, these won't emit any values.
+
+- `close`: an RxJS observable to the command's close events.
+  See [`CloseEvent`](#CloseEvent) for more information.
+- `start()`: starts the command and sets up all of the above streams
+- `send(message[, handle, options])`: sends a message to the underlying process via IPC channels,
+  returning a promise that resolves once the message has been sent.
+  See [Node.js docs](https://nodejs.org/docs/latest/api/child_process.html#subprocesssendmessage-sendhandle-options-callback).
+- `kill([signal])`: kills the command, optionally specifying a signal (e.g. `SIGTERM`, `SIGKILL`, etc).
+
+### `MessageEvent`
+
+An object that represents a message that was received from/sent to the underlying command process.<br>
+It has the following properties:
+
+- `message`: the message itself.
+- `handle`: a [`net.Socket`](https://nodejs.org/docs/latest/api/net.html#class-netsocket),
+  [`net.Server`](https://nodejs.org/docs/latest/api/net.html#class-netserver) or
+  [`dgram.Socket`](https://nodejs.org/docs/latest/api/dgram.html#class-dgramsocket),
+  if one was sent, or `undefined`.
+
+### `CloseEvent`
+
+An object with information about a command's closing event.<br>
+It contains the following properties:
+
+- `command`: a stripped down version of [`Command`](#command), including only `name`, `command`, `env` and `cwd` properties.
+- `index`: the index of the command among all commands spawned.
+- `killed`: whether the command exited because it was killed.
+- `exitCode`: the exit code of the command's process, or the signal which it was killed with.
+- `timings`: an object in the shape `{ startDate, endDate, durationSeconds }`.
+
+## FAQ
+
+- Process exited with code _null_?
+
+  From [Node child_process documentation](http://nodejs.org/api/child_process.html#child_process_event_exit), `exit` event:
+
+  > This event is emitted after the child process ends. If the process
+  > terminated normally, code is the final exit code of the process,
+  > otherwise null. If the process terminated due to receipt of a signal,
+  > signal is the string name of the signal, otherwise null.
+
+  So _null_ means the process didn't terminate normally. This will make **concurrently**
+  to return non-zero exit code too.
+
+- Does this work with the npm-replacements [yarn](https://github.com/yarnpkg/yarn), [pnpm](https://pnpm.js.org/), or [Bun](https://bun.sh/)?
+
+  Yes! In all examples above, you may replace "`npm`" with "`yarn`", "`pnpm`", or "`bun`".

node_modules/concurrently/docs/README.md

@@ -0,0 +1,13 @@
+# Concurrently Documentation
+
+## CLI
+
+These articles cover using concurrently through CLI:
+
+- [Prefixing](./cli/prefixing.md)
+- [Output Control](./cli/output-control.md)
+- [Shortcuts](./cli/shortcuts.md)
+- [Restarting Commands](./cli/restarting.md)
+- [Input Handling](./cli/input-handling.md)
+- [Passthrough Arguments](./cli/passthrough-arguments.md)
+- [Configuration](./cli/configuration.md)

node_modules/concurrently/node_modules/cliui/README.md

@@ -0,0 +1,141 @@
+# cliui
+
+![ci](https://github.com/yargs/cliui/workflows/ci/badge.svg)
+[![NPM version](https://img.shields.io/npm/v/cliui.svg)](https://www.npmjs.com/package/cliui)
+[![Conventional Commits](https://img.shields.io/badge/Conventional%20Commits-1.0.0-yellow.svg)](https://conventionalcommits.org)
+![nycrc config on GitHub](https://img.shields.io/nycrc/yargs/cliui)
+
+easily create complex multi-column command-line-interfaces.
+
+## Example
+
+```js
+const ui = require('cliui')()
+
+ui.div('Usage: $0 [command] [options]')
+
+ui.div({
+  text: 'Options:',
+  padding: [2, 0, 1, 0]
+})
+
+ui.div(
+  {
+    text: "-f, --file",
+    width: 20,
+    padding: [0, 4, 0, 4]
+  },
+  {
+    text: "the file to load." +
+      chalk.green("(if this description is long it wraps).")
+    ,
+    width: 20
+  },
+  {
+    text: chalk.red("[required]"),
+    align: 'right'
+  }
+)
+
+console.log(ui.toString())
+```
+
+## Deno/ESM Support
+
+As of `v7` `cliui` supports [Deno](https://github.com/denoland/deno) and
+[ESM](https://nodejs.org/api/esm.html#esm_ecmascript_modules):
+
+```typescript
+import cliui from "https://deno.land/x/cliui/deno.ts";
+
+const ui = cliui({})
+
+ui.div('Usage: $0 [command] [options]')
+
+ui.div({
+  text: 'Options:',
+  padding: [2, 0, 1, 0]
+})
+
+ui.div({
+  text: "-f, --file",
+  width: 20,
+  padding: [0, 4, 0, 4]
+})
+
+console.log(ui.toString())
+```
+
+<img width="500" src="screenshot.png">
+
+## Layout DSL
+
+cliui exposes a simple layout DSL:
+
+If you create a single `ui.div`, passing a string rather than an
+object:
+
+* `\n`: characters will be interpreted as new rows.
+* `\t`: characters will be interpreted as new columns.
+* `\s`: characters will be interpreted as padding.
+
+**as an example...**
+
+```js
+var ui = require('./')({
+  width: 60
+})
+
+ui.div(
+  'Usage: node ./bin/foo.js\n' +
+  '  <regex>\t  provide a regex\n' +
+  '  <glob>\t  provide a glob\t [required]'
+)
+
+console.log(ui.toString())
+```
+
+**will output:**
+
+```shell
+Usage: node ./bin/foo.js
+  <regex>  provide a regex
+  <glob>   provide a glob          [required]
+```
+
+## Methods
+
+```js
+cliui = require('cliui')
+```
+
+### cliui({width: integer})
+
+Specify the maximum width of the UI being generated.
+If no width is provided, cliui will try to get the current window's width and use it, and if that doesn't work, width will be set to `80`.
+
+### cliui({wrap: boolean})
+
+Enable or disable the wrapping of text in a column.
+
+### cliui.div(column, column, column)
+
+Create a row with any number of columns, a column
+can either be a string, or an object with the following
+options:
+
+* **text:** some text to place in the column.
+* **width:** the width of a column.
+* **align:** alignment, `right` or `center`.
+* **padding:** `[top, right, bottom, left]`.
+* **border:** should a border be placed around the div?
+
+### cliui.span(column, column, column)
+
+Similar to `div`, except the next row will be appended without
+a new line being created.
+
+### cliui.resetOutput()
+
+Resets the UI elements of the current cliui instance, maintaining the values
+set for `width` and `wrap`.

node_modules/concurrently/node_modules/emoji-regex/README.md

@@ -0,0 +1,73 @@
+# emoji-regex [![Build status](https://travis-ci.org/mathiasbynens/emoji-regex.svg?branch=master)](https://travis-ci.org/mathiasbynens/emoji-regex)
+
+_emoji-regex_ offers a regular expression to match all emoji symbols (including textual representations of emoji) as per the Unicode Standard.
+
+This repository contains a script that generates this regular expression based on [the data from Unicode v12](https://github.com/mathiasbynens/unicode-12.0.0). Because of this, the regular expression can easily be updated whenever new emoji are added to the Unicode standard.
+
+## Installation
+
+Via [npm](https://www.npmjs.com/):
+
+```bash
+npm install emoji-regex
+```
+
+In [Node.js](https://nodejs.org/):
+
+```js
+const emojiRegex = require('emoji-regex');
+// Note: because the regular expression has the global flag set, this module
+// exports a function that returns the regex rather than exporting the regular
+// expression itself, to make it impossible to (accidentally) mutate the
+// original regular expression.
+
+const text = `
+\u{231A}: ⌚ default emoji presentation character (Emoji_Presentation)
+\u{2194}\u{FE0F}: ↔️ default text presentation character rendered as emoji
+\u{1F469}: 👩 emoji modifier base (Emoji_Modifier_Base)
+\u{1F469}\u{1F3FF}: 👩🏿 emoji modifier base followed by a modifier
+`;
+
+const regex = emojiRegex();
+let match;
+while (match = regex.exec(text)) {
+  const emoji = match[0];
+  console.log(`Matched sequence ${ emoji } — code points: ${ [...emoji].length }`);
+}
+```
+
+Console output:
+
+```
+Matched sequence ⌚ — code points: 1
+Matched sequence ⌚ — code points: 1
+Matched sequence ↔️ — code points: 2
+Matched sequence ↔️ — code points: 2
+Matched sequence 👩 — code points: 1
+Matched sequence 👩 — code points: 1
+Matched sequence 👩🏿 — code points: 2
+Matched sequence 👩🏿 — code points: 2
+```
+
+To match emoji in their textual representation as well (i.e. emoji that are not `Emoji_Presentation` symbols and that aren’t forced to render as emoji by a variation selector), `require` the other regex:
+
+```js
+const emojiRegex = require('emoji-regex/text.js');
+```
+
+Additionally, in environments which support ES2015 Unicode escapes, you may `require` ES2015-style versions of the regexes:
+
+```js
+const emojiRegex = require('emoji-regex/es2015/index.js');
+const emojiRegexText = require('emoji-regex/es2015/text.js');
+```
+
+## Author
+
+| [![twitter/mathias](https://gravatar.com/avatar/24e08a9ea84deb17ae121074d0f17125?s=70)](https://twitter.com/mathias "Follow @mathias on Twitter") |
+|---|
+| [Mathias Bynens](https://mathiasbynens.be/) |
+
+## License
+
+_emoji-regex_ is available under the [MIT](https://mths.be/mit) license.