muhammara 2.3.0 → 2.6.0

package/muhammara.js

@@ -15,7 +15,7 @@ muhammara.PDFWriter.prototype.getEvents = function() {
     return this.events;
 }
 
-muhammara.PDFWriter.prototype.triggerDocumentExtensionEvent = function(eventName,eventParams) {
+muhammara.PDFWriter.prototype.triggerDocumentExtensionEvent = function(eventName, eventParams) {
     eventParams.writer = this;
     this.getEvents().emit(eventName,eventParams);
 }

package/node_modules/concat-map/package.json

@@ -2,7 +2,7 @@
   "_from": "concat-map@0.0.1",
   "_id": "concat-map@0.0.1",
   "_inBundle": false,
-  "_integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=",
+  "_integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
   "_location": "/concat-map",
   "_phantomChildren": {},
   "_requested": {

package/node_modules/console-control-strings/package.json

@@ -2,7 +2,7 @@
   "_from": "console-control-strings@^1.1.0",
   "_id": "console-control-strings@1.1.0",
   "_inBundle": false,
-  "_integrity": "sha1-PXz0Rk22RG6mRL9LOVB/mFEAjo4=",
+  "_integrity": "sha512-ty/fTekppD2fIwRvnZAVdeOiGd1c7YXEixbgJTNzqcxJWKQnjJ/V1bNEEE6hygpM3WjwHFUVK6HTjWSzV4a8sQ==",
   "_location": "/console-control-strings",
   "_phantomChildren": {},
   "_requested": {

package/node_modules/delegates/package.json

@@ -2,7 +2,7 @@
   "_from": "delegates@^1.0.0",
   "_id": "delegates@1.0.0",
   "_inBundle": false,
-  "_integrity": "sha1-hMbhWbgZBP3KWaDvRM2HDTElD5o=",
+  "_integrity": "sha512-bd2L678uiWATM6m5Z1VzNCErI3jiGzt6HGY8OVICs40JQq/HALfbyNJmp0UDakEY4pMMaN0Ly5om/B1VI/+xfQ==",
   "_location": "/delegates",
   "_phantomChildren": {},
   "_requested": {

package/node_modules/fs.realpath/package.json

@@ -2,7 +2,7 @@
   "_from": "fs.realpath@^1.0.0",
   "_id": "fs.realpath@1.0.0",
   "_inBundle": false,
-  "_integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8=",
+  "_integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==",
   "_location": "/fs.realpath",
   "_phantomChildren": {},
   "_requested": {

package/node_modules/glob/common.js

@@ -110,6 +110,8 @@ function setopts (self, pattern, options) {
   // Note that they are not supported in Glob itself anyway.
   options.nonegate = true
   options.nocomment = true
+  // always treat \ in patterns as escapes, not path separators
+  options.allowWindowsEscape = false
 
   self.minimatch = new Minimatch(pattern, options)
   self.options = self.minimatch.options

package/node_modules/glob/glob.js

@@ -342,7 +342,10 @@ Glob.prototype._process = function (pattern, index, inGlobStar, cb) {
   var read
   if (prefix === null)
     read = '.'
-  else if (isAbsolute(prefix) || isAbsolute(pattern.join('/'))) {
+  else if (isAbsolute(prefix) ||
+      isAbsolute(pattern.map(function (p) {
+        return typeof p === 'string' ? p : '[*]'
+      }).join('/'))) {
     if (!prefix || !isAbsolute(prefix))
       prefix = '/' + prefix
     read = prefix

package/node_modules/glob/package.json

@@ -1,8 +1,8 @@
 {
   "_from": "glob@^7.1.3",
-  "_id": "glob@7.2.0",
+  "_id": "glob@7.2.3",
   "_inBundle": false,
-  "_integrity": "sha512-lmLf6gtyrPq8tTjSmrO94wBeQbFR3HbLHbuyD69wuyQkImp2hWqMGB47OX65FBkPffO641IP9jWa1z4ivqG26Q==",
+  "_integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==",
   "_location": "/glob",
   "_phantomChildren": {},
   "_requested": {
@@ -18,8 +18,8 @@
   "_requiredBy": [
     "/rimraf"
   ],
-  "_resolved": "https://registry.npmjs.org/glob/-/glob-7.2.0.tgz",
-  "_shasum": "d15535af7732e02e948f4c41628bd910293f6023",
+  "_resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz",
+  "_shasum": "b8df0fb802bbfa8e89bd1d938b4e16578ed44f2b",
   "_spec": "glob@^7.1.3",
   "_where": "/home/runner/work/MuhammaraJS/MuhammaraJS/node_modules/rimraf",
   "author": {
@@ -35,7 +35,7 @@
     "fs.realpath": "^1.0.0",
     "inflight": "^1.0.4",
     "inherits": "2",
-    "minimatch": "^3.0.4",
+    "minimatch": "^3.1.1",
     "once": "^1.3.0",
     "path-is-absolute": "^1.0.0"
   },
@@ -63,6 +63,9 @@
   "license": "ISC",
   "main": "glob.js",
   "name": "glob",
+  "publishConfig": {
+    "tag": "v7-legacy"
+  },
   "repository": {
     "type": "git",
     "url": "git://github.com/isaacs/node-glob.git"
@@ -81,5 +84,5 @@
     "after": "test/zz-cleanup.js",
     "jobs": 1
   },
-  "version": "7.2.0"
+  "version": "7.2.3"
 }

package/node_modules/glob/sync.js

@@ -48,7 +48,7 @@ function GlobSync (pattern, options) {
 }
 
 GlobSync.prototype._finish = function () {
-  assert(this instanceof GlobSync)
+  assert.ok(this instanceof GlobSync)
   if (this.realpath) {
     var self = this
     this.matches.forEach(function (matchset, index) {
@@ -72,7 +72,7 @@ GlobSync.prototype._finish = function () {
 
 
 GlobSync.prototype._process = function (pattern, index, inGlobStar) {
-  assert(this instanceof GlobSync)
+  assert.ok(this instanceof GlobSync)
 
   // Get the first [n] parts of pattern that are all strings.
   var n = 0
@@ -109,7 +109,10 @@ GlobSync.prototype._process = function (pattern, index, inGlobStar) {
   var read
   if (prefix === null)
     read = '.'
-  else if (isAbsolute(prefix) || isAbsolute(pattern.join('/'))) {
+  else if (isAbsolute(prefix) ||
+      isAbsolute(pattern.map(function (p) {
+        return typeof p === 'string' ? p : '[*]'
+      }).join('/'))) {
     if (!prefix || !isAbsolute(prefix))
       prefix = '/' + prefix
     read = prefix

package/node_modules/has-unicode/package.json

@@ -2,7 +2,7 @@
   "_from": "has-unicode@^2.0.1",
   "_id": "has-unicode@2.0.1",
   "_inBundle": false,
-  "_integrity": "sha1-4Ob+aijPUROIVeCG0Wkedx3iqLk=",
+  "_integrity": "sha512-8Rf9Y83NBReMnx0gFzA8JImQACstCYWUplepDa9xprwwtmgEZUF0h/i5xSA625zB/I37EtrswSST6OXxwaaIJQ==",
   "_location": "/has-unicode",
   "_phantomChildren": {},
   "_requested": {

package/node_modules/inflight/package.json

@@ -2,7 +2,7 @@
   "_from": "inflight@^1.0.4",
   "_id": "inflight@1.0.6",
   "_inBundle": false,
-  "_integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=",
+  "_integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==",
   "_location": "/inflight",
   "_phantomChildren": {},
   "_requested": {

package/node_modules/minimatch/package.json

@@ -1,5 +1,5 @@
 {
-  "_from": "minimatch@^3.0.4",
+  "_from": "minimatch@^3.1.1",
   "_id": "minimatch@3.1.2",
   "_inBundle": false,
   "_integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
@@ -8,19 +8,19 @@
   "_requested": {
     "type": "range",
     "registry": true,
-    "raw": "minimatch@^3.0.4",
+    "raw": "minimatch@^3.1.1",
     "name": "minimatch",
     "escapedName": "minimatch",
-    "rawSpec": "^3.0.4",
+    "rawSpec": "^3.1.1",
     "saveSpec": null,
-    "fetchSpec": "^3.0.4"
+    "fetchSpec": "^3.1.1"
   },
   "_requiredBy": [
     "/glob"
   ],
   "_resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
   "_shasum": "19cd194bfd3e428f049a70817c038d89ab4be35b",
-  "_spec": "minimatch@^3.0.4",
+  "_spec": "minimatch@^3.1.1",
   "_where": "/home/runner/work/MuhammaraJS/MuhammaraJS/node_modules/glob",
   "author": {
     "name": "Isaac Z. Schlueter",

package/node_modules/minipass/LICENSE

@@ -1,6 +1,6 @@
 The ISC License
 
-Copyright (c) npm, Inc. and Contributors
+Copyright (c) 2017-2022 npm, Inc., Isaac Z. Schlueter, and Contributors
 
 Permission to use, copy, modify, and/or distribute this software for any
 purpose with or without fee is hereby granted, provided that the above

package/node_modules/minipass/README.md

@@ -17,9 +17,6 @@ from this stream via `'data'` events or by calling `pipe()` into some other
 stream.  Calling `read()` requires the buffer to be flattened in some
 cases, which requires copying memory.
 
-There is also no `unpipe()` method.  Once you start piping, there is no
-stopping it!
-
 If you set `objectMode: true` in the options, then whatever is written will
 be emitted.  Otherwise, it'll do a minimal amount of Buffer copying to
 ensure proper Streams semantics when `read(n)` is called.
@@ -63,6 +60,10 @@ some ways superior to) Node.js core streams.
 Please read these caveats if you are familiar with node-core streams and
 intend to use Minipass streams in your programs.
 
+You can avoid most of these differences entirely (for a very
+small performance penalty) by setting `{async: true}` in the
+constructor options.
+
 ### Timing
 
 Minipass streams are designed to support synchronous use-cases.  Thus, data
@@ -82,6 +83,82 @@ This non-deferring approach makes Minipass streams much easier to reason
 about, especially in the context of Promises and other flow-control
 mechanisms.
 
+Example:
+
+```js
+const Minipass = require('minipass')
+const stream = new Minipass({ async: true })
+stream.on('data', () => console.log('data event'))
+console.log('before write')
+stream.write('hello')
+console.log('after write')
+// output:
+// before write
+// data event
+// after write
+```
+
+### Exception: Async Opt-In
+
+If you wish to have a Minipass stream with behavior that more
+closely mimics Node.js core streams, you can set the stream in
+async mode either by setting `async: true` in the constructor
+options, or by setting `stream.async = true` later on.
+
+```js
+const Minipass = require('minipass')
+const asyncStream = new Minipass({ async: true })
+asyncStream.on('data', () => console.log('data event'))
+console.log('before write')
+asyncStream.write('hello')
+console.log('after write')
+// output:
+// before write
+// after write
+// data event <-- this is deferred until the next tick
+```
+
+Switching _out_ of async mode is unsafe, as it could cause data
+corruption, and so is not enabled.  Example:
+
+```js
+const Minipass = require('minipass')
+const stream = new Minipass({ encoding: 'utf8' })
+stream.on('data', chunk => console.log(chunk))
+stream.async = true
+console.log('before writes')
+stream.write('hello')
+setStreamSyncAgainSomehow(stream) // <-- this doesn't actually exist!
+stream.write('world')
+console.log('after writes')
+// hypothetical output would be:
+// before writes
+// world
+// after writes
+// hello
+// NOT GOOD!
+```
+
+To avoid this problem, once set into async mode, any attempt to
+make the stream sync again will be ignored.
+
+```js
+const Minipass = require('minipass')
+const stream = new Minipass({ encoding: 'utf8' })
+stream.on('data', chunk => console.log(chunk))
+stream.async = true
+console.log('before writes')
+stream.write('hello')
+stream.async = false // <-- no-op, stream already async
+stream.write('world')
+console.log('after writes')
+// actual output:
+// before writes
+// after writes
+// hello
+// world
+```
+
 ### No High/Low Water Marks
 
 Node.js core streams will optimistically fill up a buffer, returning `true`
@@ -97,6 +174,9 @@ If the data has nowhere to go, then `write()` returns false, and the data
 sits in a buffer, to be drained out immediately as soon as anyone consumes
 it.
 
+Since nothing is ever buffered unnecessarily, there is much less
+copying data, and less bookkeeping about buffer capacity levels.
+
 ### Hazards of Buffering (or: Why Minipass Is So Fast)
 
 Since data written to a Minipass stream is immediately written all the way
@@ -181,6 +261,8 @@ moving on to the next entry in an archive parse stream, etc.) then be sure
 to call `stream.pause()` on creation, and then `stream.resume()` once you
 are ready to respond to the `end` event.
 
+However, this is _usually_ not a problem because:
+
 ### Emit `end` When Asked
 
 One hazard of immediately emitting `'end'` is that you may not yet have had
@@ -197,6 +279,18 @@ To prevent calling handlers multiple times who would not expect multiple
 ends to occur, all listeners are removed from the `'end'` event whenever it
 is emitted.
 
+### Emit `error` When Asked
+
+The most recent error object passed to the `'error'` event is
+stored on the stream.  If a new `'error'` event handler is added,
+and an error was previously emitted, then the event handler will
+be called immediately (or on `process.nextTick` in the case of
+async streams).
+
+This makes it much more difficult to end up trying to interact
+with a broken stream, if the error handler is added after an
+error was previously emitted.
+
 ### Impact of "immediate flow" on Tee-streams
 
 A "tee stream" is a stream piping to multiple destinations:
@@ -221,7 +315,7 @@ src.pipe(dest1) // 'foo' chunk flows to dest1 immediately, and is gone
 src.pipe(dest2) // gets nothing!
 ```
 
-The solution is to create a dedicated tee-stream junction that pipes to
+One solution is to create a dedicated tee-stream junction that pipes to
 both locations, and then pipe to _that_ instead.
 
 ```js
@@ -258,6 +352,13 @@ tee.on('data', handler2)
 src.pipe(tee)
 ```
 
+All of the hazards in this section are avoided by setting `{
+async: true }` in the Minipass constructor, or by setting
+`stream.async = true` afterwards.  Note that this does add some
+overhead, so should only be done in cases where you are willing
+to lose a bit of performance in order to avoid having to refactor
+program logic.
+
 ## USAGE
 
 It's a stream!  Use it like a stream and it'll most likely do what you
@@ -279,6 +380,10 @@ mp.end('bar')
   by default if you write() something other than a string or Buffer at any
   point.  Setting `objectMode: true` will prevent setting any encoding
   value.
+* `async` Defaults to `false`.  Set to `true` to defer data
+  emission until next tick.  This reduces performance slightly,
+  but makes Minipass streams use timing behavior closer to Node
+  core streams.  See [Timing](#timing) for more details.
 
 ### API
 
@@ -300,9 +405,19 @@ streams.
   from being emitted for empty streams until the stream is resumed.
 * `resume()` - Resume the stream.  If there's data in the buffer, it is all
   discarded.  Any buffered events are immediately emitted.
-* `pipe(dest)` - Send all output to the stream provided.  There is no way
-  to unpipe.  When data is emitted, it is immediately written to any and
-  all pipe destinations.
+* `pipe(dest)` - Send all output to the stream provided.  When
+  data is emitted, it is immediately written to any and all pipe
+  destinations.  (Or written on next tick in `async` mode.)
+* `unpipe(dest)` - Stop piping to the destination stream.  This
+  is immediate, meaning that any asynchronously queued data will
+  _not_ make it to the destination when running in `async` mode.
+    * `options.end` - Boolean, end the destination stream when
+      the source stream ends.  Default `true`.
+    * `options.proxyErrors` - Boolean, proxy `error` events from
+      the source stream to the destination stream.  Note that
+      errors are _not_ proxied after the pipeline terminates,
+      either due to the source emitting `'end'` or manually
+      unpiping with `src.unpipe(dest)`.  Default `false`.
 * `on(ev, fn)`, `emit(ev, fn)` - Minipass streams are EventEmitters.  Some
   events are given special treatment, however.  (See below under "events".)
 * `promise()` - Returns a Promise that resolves when the stream emits

package/node_modules/minipass/index.d.ts

@@ -0,0 +1,149 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events'
+import { Stream } from 'stream'
+
+export type Encoding = BufferEncoding | 'buffer' | null
+
+interface Writable extends EventEmitter {
+  end(): any
+  write(chunk: any, ...args: any[]): any
+}
+
+interface Readable extends EventEmitter {
+  pause(): any
+  resume(): any
+  pipe(): any
+}
+
+interface Pipe<R, W> {
+  src: Minipass<R, W>
+  dest: Writable
+  opts: PipeOptions
+}
+
+type DualIterable<T> = Iterable<T> & AsyncIterable<T>
+
+type ContiguousData = Buffer | ArrayBufferLike | ArrayBufferView | string
+
+type BufferOrString = Buffer | string
+
+export default class Minipass<
+    RType extends any = Buffer,
+    WType extends any = RType extends BufferOrString ? ContiguousData : RType
+  >
+  extends Stream
+  implements DualIterable<RType>
+{
+  static isStream(stream: any): stream is Readable | Writable
+
+  readonly bufferLength: number
+  readonly flowing: boolean
+  readonly writable: boolean
+  readonly readable: boolean
+  readonly paused: boolean
+  readonly emittedEnd: boolean
+  readonly destroyed: boolean
+
+  /**
+   * Not technically private or readonly, but not safe to mutate.
+   */
+  private readonly buffer: RType[]
+  private readonly pipes: Pipe<RType, WType>[]
+
+  /**
+   * Technically writable, but mutating it can change the type,
+   * so is not safe to do in TypeScript.
+   */
+  readonly objectMode: boolean
+  async: boolean
+
+  /**
+   * Note: encoding is not actually read-only, and setEncoding(enc)
+   * exists. However, this type definition will insist that TypeScript
+   * programs declare the type of a Minipass stream up front, and if
+   * that type is string, then an encoding MUST be set in the ctor. If
+   * the type is Buffer, then the encoding must be missing, or set to
+   * 'buffer' or null. If the type is anything else, then objectMode
+   * must be set in the constructor options.  So there is effectively
+   * no allowed way that a TS program can set the encoding after
+   * construction, as doing so will destroy any hope of type safety.
+   * TypeScript does not provide many options for changing the type of
+   * an object at run-time, which is what changing the encoding does.
+   */
+  readonly encoding: Encoding
+  // setEncoding(encoding: Encoding): void
+
+  // Options required if not reading buffers
+  constructor(
+    ...args: RType extends Buffer
+      ? [] | [Options<RType>]
+      : [Options<RType>]
+  )
+
+  write(chunk: WType, cb?: () => void): boolean
+  write(chunk: WType, encoding?: Encoding, cb?: () => void): boolean
+  read(size?: number): RType
+  end(cb?: () => void): this
+  end(chunk: any, cb?: () => void): this
+  end(chunk: any, encoding?: Encoding, cb?: () => void): this
+  pause(): void
+  resume(): void
+  promise(): Promise<void>
+  collect(): Promise<RType[]>
+
+  concat(): RType extends BufferOrString ? Promise<RType> : never
+  destroy(er?: any): void
+  pipe<W extends Writable>(dest: W, opts?: PipeOptions): W
+  unpipe<W extends Writable>(dest: W): void
+
+  /**
+   * alias for on()
+   */
+  addEventHandler(event: string, listener: (...args: any[]) => any): this
+
+  on(event: string, listener: (...args: any[]) => any): this
+  on(event: 'data', listener: (chunk: RType) => any): this
+  on(event: 'error', listener: (error: any) => any): this
+  on(
+    event:
+      | 'readable'
+      | 'drain'
+      | 'resume'
+      | 'end'
+      | 'prefinish'
+      | 'finish'
+      | 'close',
+    listener: () => any
+  ): this
+
+  [Symbol.iterator](): Iterator<RType>
+  [Symbol.asyncIterator](): AsyncIterator<RType>
+}
+
+interface StringOptions {
+  encoding: BufferEncoding
+  objectMode?: boolean
+  async?: boolean
+}
+
+interface BufferOptions {
+  encoding?: null | 'buffer'
+  objectMode?: boolean
+  async?: boolean
+}
+
+interface ObjectModeOptions {
+  objectMode: true
+  async?: boolean
+}
+
+export declare interface PipeOptions {
+  end?: boolean
+  proxyErrors?: boolean
+}
+
+export declare type Options<T> = T extends string
+  ? StringOptions
+  : T extends Buffer
+  ? BufferOptions
+  : ObjectModeOptions