1 files changed, 0 insertions, 157 deletions
diff --git a/inc/3rdparty/htmlpurifier/HTMLPurifier/Zipper.php b/inc/3rdparty/htmlpurifier/HTMLPurifier/Zipper.php
deleted file mode 100644
index a358fff0..00000000
--- a/inc/3rdparty/htmlpurifier/HTMLPurifier/Zipper.php
+++ /dev/null
@@ -1,157 +0,0 @@
-<?php
-/**
- * A zipper is a purely-functional data structure which contains
- * a focus that can be efficiently manipulated.  It is known as
- * a "one-hole context".  This mutable variant implements a zipper
- * for a list as a pair of two arrays, laid out as follows:
- *
- *      Base list: 1 2 3 4 [ ] 6 7 8 9
- *      Front list: 1 2 3 4
- *      Back list: 9 8 7 6
- *
- * User is expected to keep track of the "current element" and properly
- * fill it back in as necessary.  (ToDo: Maybe it's more user friendly
- * to implicitly track the current element?)
- *
- * Nota bene: the current class gets confused if you try to store NULLs
- * in the list.
- */
-class HTMLPurifier_Zipper
-{
-    public $front, $back;
-    public function __construct($front, $back) {
-        $this->front = $front;
-        $this->back = $back;
-    }
-    /**
-     * Creates a zipper from an array, with a hole in the
-     * 0-index position.
-     * @param Array to zipper-ify.
-     * @return Tuple of zipper and element of first position.
-     */
-    static public function fromArray($array) {
-        $z = new self(array(), array_reverse($array));
-        $t = $z->delete(); // delete the "dummy hole"
-        return array($z, $t);
-    }
-    /**
-     * Convert zipper back into a normal array, optionally filling in
-     * the hole with a value. (Usually you should supply a $t, unless you
-     * are at the end of the array.)
-     */
-    public function toArray($t = NULL) {
-        $a = $this->front;
-        if ($t !== NULL) $a[] = $t;
-        for ($i = count($this->back)-1; $i >= 0; $i--) {
-            $a[] = $this->back[$i];
-        }
-        return $a;
-    }
-    /**
-     * Move hole to the next element.
-     * @param $t Element to fill hole with
-     * @return Original contents of new hole.
-     */
-    public function next($t) {
-        if ($t !== NULL) array_push($this->front, $t);
-        return empty($this->back) ? NULL : array_pop($this->back);
-    }
-    /**
-     * Iterated hole advancement.
-     * @param $t Element to fill hole with
-     * @param $i How many forward to advance hole
-     * @return Original contents of new hole, i away
-     */
-    public function advance($t, $n) {
-        for ($i = 0; $i < $n; $i++) {
-            $t = $this->next($t);
-        }
-        return $t;
-    }
-    /**
-     * Move hole to the previous element
-     * @param $t Element to fill hole with
-     * @return Original contents of new hole.
-     */
-    public function prev($t) {
-        if ($t !== NULL) array_push($this->back, $t);
-        return empty($this->front) ? NULL : array_pop($this->front);
-    }
-    /**
-     * Delete contents of current hole, shifting hole to
-     * next element.
-     * @return Original contents of new hole.
-     */
-    public function delete() {
-        return empty($this->back) ? NULL : array_pop($this->back);
-    }
-    /**
-     * Returns true if we are at the end of the list.
-     * @return bool
-     */
-    public function done() {
-        return empty($this->back);
-    }
-    /**
-     * Insert element before hole.
-     * @param Element to insert
-     */
-    public function insertBefore($t) {
-        if ($t !== NULL) array_push($this->front, $t);
-    }
-    /**
-     * Insert element after hole.
-     * @param Element to insert
-     */
-    public function insertAfter($t) {
-        if ($t !== NULL) array_push($this->back, $t);
-    }
-    /**
-     * Splice in multiple elements at hole.  Functional specification
-     * in terms of array_splice:
-     *
-     *      $arr1 = $arr;
-     *      $old1 = array_splice($arr1, $i, $delete, $replacement);
-     *
-     *      list($z, $t) = HTMLPurifier_Zipper::fromArray($arr);
-     *      $t = $z->advance($t, $i);
-     *      list($old2, $t) = $z->splice($t, $delete, $replacement);
-     *      $arr2 = $z->toArray($t);
-     *
-     *      assert($old1 === $old2);
-     *      assert($arr1 === $arr2);
-     *
-     * NB: the absolute index location after this operation is
-     * *unchanged!*
-     *
-     * @param Current contents of hole.
-     */
-    public function splice($t, $delete, $replacement) {
-        // delete
-        $old = array();
-        $r = $t;
-        for ($i = $delete; $i > 0; $i--) {
-            $old[] = $r;
-            $r = $this->delete();
-        }
-        // insert
-        for ($i = count($replacement)-1; $i >= 0; $i--) {
-            $this->insertAfter($r);
-            $r = $replacement[$i];
-        }
-        return array($old, $r);
-    }
-}

diff --git a/inc/3rdparty/htmlpurifier/HTMLPurifier/Zipper.php b/inc/3rdparty/htmlpurifier/HTMLPurifier/Zipper.php deleted file mode 100644 index a358fff0..00000000 --- a/inc/3rdparty/htmlpurifier/HTMLPurifier/Zipper.php +++ /dev/null
@@ -1,157 +0,0 @@
1	<?php
2
3	/**
4	* A zipper is a purely-functional data structure which contains
5	* a focus that can be efficiently manipulated. It is known as
6	* a "one-hole context". This mutable variant implements a zipper
7	* for a list as a pair of two arrays, laid out as follows:
8	*
9	* Base list: 1 2 3 4 [ ] 6 7 8 9
10	* Front list: 1 2 3 4
11	* Back list: 9 8 7 6
12	*
13	* User is expected to keep track of the "current element" and properly
14	* fill it back in as necessary. (ToDo: Maybe it's more user friendly
15	* to implicitly track the current element?)
16	*
17	* Nota bene: the current class gets confused if you try to store NULLs
18	* in the list.
19	*/
20
21	class HTMLPurifier_Zipper
22	{
23	public $front, $back;
24
25	public function __construct($front, $back) {
26	$this->front = $front;
27	$this->back = $back;
28	}
29
30	/**
31	* Creates a zipper from an array, with a hole in the
32	* 0-index position.
33	* @param Array to zipper-ify.
34	* @return Tuple of zipper and element of first position.
35	*/
36	static public function fromArray($array) {
37	$z = new self(array(), array_reverse($array));
38	$t = $z->delete(); // delete the "dummy hole"
39	return array($z, $t);
40	}
41
42	/**
43	* Convert zipper back into a normal array, optionally filling in
44	* the hole with a value. (Usually you should supply a $t, unless you
45	* are at the end of the array.)
46	*/
47	public function toArray($t = NULL) {
48	$a = $this->front;
49	if ($t !== NULL) $a[] = $t;
50	for ($i = count($this->back)-1; $i >= 0; $i--) {
51	$a[] = $this->back[$i];
52	}
53	return $a;
54	}
55
56	/**
57	* Move hole to the next element.
58	* @param $t Element to fill hole with
59	* @return Original contents of new hole.
60	*/
61	public function next($t) {
62	if ($t !== NULL) array_push($this->front, $t);
63	return empty($this->back) ? NULL : array_pop($this->back);
64	}
65
66	/**
67	* Iterated hole advancement.
68	* @param $t Element to fill hole with
69	* @param $i How many forward to advance hole
70	* @return Original contents of new hole, i away
71	*/
72	public function advance($t, $n) {
73	for ($i = 0; $i < $n; $i++) {
74	$t = $this->next($t);
75	}
76	return $t;
77	}
78
79	/**
80	* Move hole to the previous element
81	* @param $t Element to fill hole with
82	* @return Original contents of new hole.
83	*/
84	public function prev($t) {
85	if ($t !== NULL) array_push($this->back, $t);
86	return empty($this->front) ? NULL : array_pop($this->front);
87	}
88
89	/**
90	* Delete contents of current hole, shifting hole to
91	* next element.
92	* @return Original contents of new hole.
93	*/
94	public function delete() {
95	return empty($this->back) ? NULL : array_pop($this->back);
96	}
97
98	/**
99	* Returns true if we are at the end of the list.
100	* @return bool
101	*/
102	public function done() {
103	return empty($this->back);
104	}
105
106	/**
107	* Insert element before hole.
108	* @param Element to insert
109	*/
110	public function insertBefore($t) {
111	if ($t !== NULL) array_push($this->front, $t);
112	}
113
114	/**
115	* Insert element after hole.
116	* @param Element to insert
117	*/
118	public function insertAfter($t) {
119	if ($t !== NULL) array_push($this->back, $t);
120	}
121
122	/**
123	* Splice in multiple elements at hole. Functional specification
124	* in terms of array_splice:
125	*
126	* $arr1 = $arr;
127	* $old1 = array_splice($arr1, $i, $delete, $replacement);
128	*
129	* list($z, $t) = HTMLPurifier_Zipper::fromArray($arr);
130	* $t = $z->advance($t, $i);
131	* list($old2, $t) = $z->splice($t, $delete, $replacement);
132	* $arr2 = $z->toArray($t);
133	*
134	* assert($old1 === $old2);
135	* assert($arr1 === $arr2);
136	*
137	* NB: the absolute index location after this operation is
138	* unchanged!
139	*
140	* @param Current contents of hole.
141	*/
142	public function splice($t, $delete, $replacement) {
143	// delete
144	$old = array();
145	$r = $t;
146	for ($i = $delete; $i > 0; $i--) {
147	$old[] = $r;
148	$r = $this->delete();
149	}
150	// insert
151	for ($i = count($replacement)-1; $i >= 0; $i--) {
152	$this->insertAfter($r);
153	$r = $replacement[$i];
154	}
155	return array($old, $r);
156	}
157	}