Context Navigation

Back to Ticket #10690

Ticket #10690: 29170.2.diff

File 29170.2.diff, 106.6 KB (added by extendwings, 11 years ago)
Patch from #29170

new file wp-includes/pear-Net_IDNA2/IDNA2.php

diff --git a/wp-includes/pear-Net_IDNA2/IDNA2.php b/wp-includes/pear-Net_IDNA2/IDNA2.php
new file mode 100644
index 0000000..3c31c47

-                      -
+<?php
+// {{{ license
+/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4 foldmethod=marker: */
+//
+// +----------------------------------------------------------------------+
+// | This library is free software; you can redistribute it and/or modify |
+// | it under the terms of the GNU Lesser General Public License as       |
+// | published by the Free Software Foundation; either version 2.1 of the |
+// | License, or (at your option) any later version.                      |
+// |                                                                      |
+// | This library is distributed in the hope that it will be useful, but  |
+// | WITHOUT ANY WARRANTY; without even the implied warranty of           |
+// | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU    |
+// | Lesser General Public License for more details.                      |
+// |                                                                      |
+// | You should have received a copy of the GNU Lesser General Public     |
+// | License along with this library; if not, write to the Free Software  |
+// | Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 |
+// | USA.                                                                 |
+// +----------------------------------------------------------------------+
+//
+// }}}
+require_once ABSPATH . WPINC . '/pear-Net_IDNA2/IDNA2/Exception.php';
+require_once ABSPATH . WPINC . '/pear-Net_IDNA2/IDNA2/Exception/Nameprep.php';
+/**
+ * Encode/decode Internationalized Domain Names.
+ *
+ * The class allows to convert internationalized domain names
+ * (see RFC 3490 for details) as they can be used with various registries worldwide
+ * to be translated between their original (localized) form and their encoded form
+ * as it will be used in the DNS (Domain Name System).
+ *
+ * The class provides two public methods, encode() and decode(), which do exactly
+ * what you would expect them to do. You are allowed to use complete domain names,
+ * simple strings and complete email addresses as well. That means, that you might
+ * use any of the following notations:
+ *
+ * - www.n�rgler.com
+ * - xn--nrgler-wxa
+ * - xn--brse-5qa.xn--knrz-1ra.info
+ *
+ * Unicode input might be given as either UTF-8 string, UCS-4 string or UCS-4
+ * array. Unicode output is available in the same formats.
+ * You can select your preferred format via {@link set_paramter()}.
+ *
+ * ACE input and output is always expected to be ASCII.
+ *
+ * @package Net
+ * @author  Markus Nix <mnix@docuverse.de>
+ * @author  Matthias Sommerfeld <mso@phlylabs.de>
+ * @author  Stefan Neufeind <pear.neufeind@speedpartner.de>
+ * @version $Id$
+ */
+class Net_IDNA2
+{
+    // {{{ npdata
+    /**
+     * These Unicode codepoints are
+     * mapped to nothing, See RFC3454 for details
+     *
+     * @static
+     * @var array
+     * @access private
+     */
+    private static $_np_map_nothing = array(
+xAD,
+x34F,
+x1806,
+x180B,
+x180C,
+x180D,
+x200B,
+x200C,
+x200D,
+x2060,
+xFE00,
+xFE01,
+xFE02,
+xFE03,
+xFE04,
+xFE05,
+xFE06,
+xFE07,
+xFE08,
+xFE09,
+xFE0A,
+xFE0B,
+xFE0C,
+xFE0D,
+xFE0E,
+xFE0F,
+xFEFF
+    );
+    /**
+     * Prohibited codepints
+     *
+     * @static
+     * @var array
+     * @access private
+     */
+    private static $_general_prohibited = array(
+,
+,
+,
+,
+,
+,
+,
+,
+,
+,
+xA,
+xB,
+xC,
+xD,
+xE,
+xF,
+x10,
+x11,
+x12,
+x13,
+x14,
+x15,
+x16,
+x17,
+x18,
+x19,
+x1A,
+x1B,
+x1C,
+x1D,
+x1E,
+x1F,
+x20,
+x21,
+x22,
+x23,
+x24,
+x25,
+x26,
+x27,
+x28,
+x29,
+x2A,
+x2B,
+x2C,
+x2F,
+x3B,
+x3C,
+x3D,
+x3E,
+x3F,
+x40,
+x5B,
+x5C,
+x5D,
+x5E,
+x5F,
+x60,
+x7B,
+x7C,
+x7D,
+x7E,
+x7F,
+x3002
+    );
+    /**
+     * Codepints prohibited by Nameprep
+     * @static
+     * @var array
+     * @access private
+     */
+    private static $_np_prohibit = array(
+xA0,
+x1680,
+x2000,
+x2001,
+x2002,
+x2003,
+x2004,
+x2005,
+x2006,
+x2007,
+x2008,
+x2009,
+x200A,
+x200B,
+x202F,
+x205F,
+x3000,
+x6DD,
+x70F,
+x180E,
+x200C,
+x200D,
+x2028,
+x2029,
+xFEFF,
+xFFF9,
+xFFFA,
+xFFFB,
+xFFFC,
+xFFFE,
+xFFFF,
+x1FFFE,
+x1FFFF,
+x2FFFE,
+x2FFFF,
+x3FFFE,
+x3FFFF,
+x4FFFE,
+x4FFFF,
+x5FFFE,
+x5FFFF,
+x6FFFE,
+x6FFFF,
+x7FFFE,
+x7FFFF,
+x8FFFE,
+x8FFFF,
+x9FFFE,
+x9FFFF,
+xAFFFE,
+xAFFFF,
+xBFFFE,
+xBFFFF,
+xCFFFE,
+xCFFFF,
+xDFFFE,
+xDFFFF,
+xEFFFE,
+xEFFFF,
+xFFFFE,
+xFFFFF,
+x10FFFE,
+x10FFFF,
+xFFF9,
+xFFFA,
+xFFFB,
+xFFFC,
+xFFFD,
+x340,
+x341,
+x200E,
+x200F,
+x202A,
+x202B,
+x202C,
+x202D,
+x202E,
+x206A,
+x206B,
+x206C,
+x206D,
+x206E,
+x206F,
+xE0001
+    );
+    /**
+     * Codepoint ranges prohibited by nameprep
+     *
+     * @static
+     * @var array
+     * @access private
+     */
+    private static $_np_prohibit_ranges = array(
+        array(0x80,     0x9F    ),
+        array(0x2060,   0x206F  ),
+        array(0x1D173,  0x1D17A ),
+        array(0xE000,   0xF8FF  ),
+        array(0xF0000,  0xFFFFD ),
+        array(0x100000, 0x10FFFD),
+        array(0xFDD0,   0xFDEF  ),
+        array(0xD800,   0xDFFF  ),
+        array(0x2FF0,   0x2FFB  ),
+        array(0xE0020,  0xE007F )
+    );
+    /**
+     * Replacement mappings (casemapping, replacement sequences, ...)
+     *
+     * @static
+     * @var array
+     * @access private
+     */
+    private static $_np_replacemaps = array(
+x41    => array(0x61),
+x42    => array(0x62),
+x43    => array(0x63),
+x44    => array(0x64),
+x45    => array(0x65),
+x46    => array(0x66),
+x47    => array(0x67),
+x48    => array(0x68),
+x49    => array(0x69),
+x4A    => array(0x6A),
+x4B    => array(0x6B),
+x4C    => array(0x6C),
+x4D    => array(0x6D),
+x4E    => array(0x6E),
+x4F    => array(0x6F),
+x50    => array(0x70),
+x51    => array(0x71),
+x52    => array(0x72),
+x53    => array(0x73),
+x54    => array(0x74),
+x55    => array(0x75),
+x56    => array(0x76),
+x57    => array(0x77),
+x58    => array(0x78),
+x59    => array(0x79),
+x5A    => array(0x7A),
+xB5    => array(0x3BC),
+xC0    => array(0xE0),
+xC1    => array(0xE1),
+xC2    => array(0xE2),
+xC3    => array(0xE3),
+xC4    => array(0xE4),
+xC5    => array(0xE5),
+xC6    => array(0xE6),
+xC7    => array(0xE7),
+xC8    => array(0xE8),
+xC9    => array(0xE9),
+xCA    => array(0xEA),
+xCB    => array(0xEB),
+xCC    => array(0xEC),
+xCD    => array(0xED),
+xCE    => array(0xEE),
+xCF    => array(0xEF),
+xD0    => array(0xF0),
+xD1    => array(0xF1),
+xD2    => array(0xF2),
+xD3    => array(0xF3),
+xD4    => array(0xF4),
+xD5    => array(0xF5),
+xD6    => array(0xF6),
+xD8    => array(0xF8),
+xD9    => array(0xF9),
+xDA    => array(0xFA),
+xDB    => array(0xFB),
+xDC    => array(0xFC),
+xDD    => array(0xFD),
+xDE    => array(0xFE),
+xDF    => array(0x73, 0x73),
+x100   => array(0x101),
+x102   => array(0x103),
+x104   => array(0x105),
+x106   => array(0x107),
+x108   => array(0x109),
+x10A   => array(0x10B),
+x10C   => array(0x10D),
+x10E   => array(0x10F),
+x110   => array(0x111),
+x112   => array(0x113),
+x114   => array(0x115),
+x116   => array(0x117),
+x118   => array(0x119),
+x11A   => array(0x11B),
+x11C   => array(0x11D),
+x11E   => array(0x11F),
+x120   => array(0x121),
+x122   => array(0x123),
+x124   => array(0x125),
+x126   => array(0x127),
+x128   => array(0x129),
+x12A   => array(0x12B),
+x12C   => array(0x12D),
+x12E   => array(0x12F),
+x130   => array(0x69, 0x307),
+x132   => array(0x133),
+x134   => array(0x135),
+x136   => array(0x137),
+x139   => array(0x13A),
+x13B   => array(0x13C),
+x13D   => array(0x13E),
+x13F   => array(0x140),
+x141   => array(0x142),
+x143   => array(0x144),
+x145   => array(0x146),
+x147   => array(0x148),
+x149   => array(0x2BC, 0x6E),
+x14A   => array(0x14B),
+x14C   => array(0x14D),
+x14E   => array(0x14F),
+x150   => array(0x151),
+x152   => array(0x153),
+x154   => array(0x155),
+x156   => array(0x157),
+x158   => array(0x159),
+x15A   => array(0x15B),
+x15C   => array(0x15D),
+x15E   => array(0x15F),
+x160   => array(0x161),
+x162   => array(0x163),
+x164   => array(0x165),
+x166   => array(0x167),
+x168   => array(0x169),
+x16A   => array(0x16B),
+x16C   => array(0x16D),
+x16E   => array(0x16F),
+x170   => array(0x171),
+x172   => array(0x173),
+x174   => array(0x175),
+x176   => array(0x177),
+x178   => array(0xFF),
+x179   => array(0x17A),
+x17B   => array(0x17C),
+x17D   => array(0x17E),
+x17F   => array(0x73),
+x181   => array(0x253),
+x182   => array(0x183),
+x184   => array(0x185),
+x186   => array(0x254),
+x187   => array(0x188),
+x189   => array(0x256),
+x18A   => array(0x257),
+x18B   => array(0x18C),
+x18E   => array(0x1DD),
+x18F   => array(0x259),
+x190   => array(0x25B),
+x191   => array(0x192),
+x193   => array(0x260),
+x194   => array(0x263),
+x196   => array(0x269),
+x197   => array(0x268),
+x198   => array(0x199),
+x19C   => array(0x26F),
+x19D   => array(0x272),
+x19F   => array(0x275),
+x1A0   => array(0x1A1),
+x1A2   => array(0x1A3),
+x1A4   => array(0x1A5),
+x1A6   => array(0x280),
+x1A7   => array(0x1A8),
+x1A9   => array(0x283),
+x1AC   => array(0x1AD),
+x1AE   => array(0x288),
+x1AF   => array(0x1B0),
+x1B1   => array(0x28A),
+x1B2   => array(0x28B),
+x1B3   => array(0x1B4),
+x1B5   => array(0x1B6),
+x1B7   => array(0x292),
+x1B8   => array(0x1B9),
+x1BC   => array(0x1BD),
+x1C4   => array(0x1C6),
+x1C5   => array(0x1C6),
+x1C7   => array(0x1C9),
+x1C8   => array(0x1C9),
+x1CA   => array(0x1CC),
+x1CB   => array(0x1CC),
+x1CD   => array(0x1CE),
+x1CF   => array(0x1D0),
+x1D1   => array(0x1D2),
+x1D3   => array(0x1D4),
+x1D5   => array(0x1D6),
+x1D7   => array(0x1D8),
+x1D9   => array(0x1DA),
+x1DB   => array(0x1DC),
+x1DE   => array(0x1DF),
+x1E0   => array(0x1E1),
+x1E2   => array(0x1E3),
+x1E4   => array(0x1E5),
+x1E6   => array(0x1E7),
+x1E8   => array(0x1E9),
+x1EA   => array(0x1EB),
+x1EC   => array(0x1ED),
+x1EE   => array(0x1EF),
+x1F0   => array(0x6A, 0x30C),
+x1F1   => array(0x1F3),
+x1F2   => array(0x1F3),
+x1F4   => array(0x1F5),
+x1F6   => array(0x195),
+x1F7   => array(0x1BF),
+x1F8   => array(0x1F9),
+x1FA   => array(0x1FB),
+x1FC   => array(0x1FD),
+x1FE   => array(0x1FF),
+x200   => array(0x201),
+x202   => array(0x203),
+x204   => array(0x205),
+x206   => array(0x207),
+x208   => array(0x209),
+x20A   => array(0x20B),
+x20C   => array(0x20D),
+x20E   => array(0x20F),
+x210   => array(0x211),
+x212   => array(0x213),
+x214   => array(0x215),
+x216   => array(0x217),
+x218   => array(0x219),
+x21A   => array(0x21B),
+x21C   => array(0x21D),
+x21E   => array(0x21F),
+x220   => array(0x19E),
+x222   => array(0x223),
+x224   => array(0x225),
+x226   => array(0x227),
+x228   => array(0x229),
+x22A   => array(0x22B),
+x22C   => array(0x22D),
+x22E   => array(0x22F),
+x230   => array(0x231),
+x232   => array(0x233),
+x345   => array(0x3B9),
+x37A   => array(0x20, 0x3B9),
+x386   => array(0x3AC),
+x388   => array(0x3AD),
+x389   => array(0x3AE),
+x38A   => array(0x3AF),
+x38C   => array(0x3CC),
+x38E   => array(0x3CD),
+x38F   => array(0x3CE),
+x390   => array(0x3B9, 0x308, 0x301),
+x391   => array(0x3B1),
+x392   => array(0x3B2),
+x393   => array(0x3B3),
+x394   => array(0x3B4),
+x395   => array(0x3B5),
+x396   => array(0x3B6),
+x397   => array(0x3B7),
+x398   => array(0x3B8),
+x399   => array(0x3B9),
+x39A   => array(0x3BA),
+x39B   => array(0x3BB),
+x39C   => array(0x3BC),
+x39D   => array(0x3BD),
+x39E   => array(0x3BE),
+x39F   => array(0x3BF),
+x3A0   => array(0x3C0),
+x3A1   => array(0x3C1),
+x3A3   => array(0x3C3),
+x3A4   => array(0x3C4),
+x3A5   => array(0x3C5),
+x3A6   => array(0x3C6),
+x3A7   => array(0x3C7),
+x3A8   => array(0x3C8),
+x3A9   => array(0x3C9),
+x3AA   => array(0x3CA),
+x3AB   => array(0x3CB),
+x3B0   => array(0x3C5, 0x308, 0x301),
+x3C2   => array(0x3C3),
+x3D0   => array(0x3B2),
+x3D1   => array(0x3B8),
+x3D2   => array(0x3C5),
+x3D3   => array(0x3CD),
+x3D4   => array(0x3CB),
+x3D5   => array(0x3C6),
+x3D6   => array(0x3C0),
+x3D8   => array(0x3D9),
+x3DA   => array(0x3DB),
+x3DC   => array(0x3DD),
+x3DE   => array(0x3DF),
+x3E0   => array(0x3E1),
+x3E2   => array(0x3E3),
+x3E4   => array(0x3E5),
+x3E6   => array(0x3E7),
+x3E8   => array(0x3E9),
+x3EA   => array(0x3EB),
+x3EC   => array(0x3ED),
+x3EE   => array(0x3EF),
+x3F0   => array(0x3BA),
+x3F1   => array(0x3C1),
+x3F2   => array(0x3C3),
+x3F4   => array(0x3B8),
+x3F5   => array(0x3B5),
+x400   => array(0x450),
+x401   => array(0x451),
+x402   => array(0x452),
+x403   => array(0x453),
+x404   => array(0x454),
+x405   => array(0x455),
+x406   => array(0x456),
+x407   => array(0x457),
+x408   => array(0x458),
+x409   => array(0x459),
+x40A   => array(0x45A),
+x40B   => array(0x45B),
+x40C   => array(0x45C),
+x40D   => array(0x45D),
+x40E   => array(0x45E),
+x40F   => array(0x45F),
+x410   => array(0x430),
+x411   => array(0x431),
+x412   => array(0x432),
+x413   => array(0x433),
+x414   => array(0x434),
+x415   => array(0x435),
+x416   => array(0x436),
+x417   => array(0x437),
+x418   => array(0x438),
+x419   => array(0x439),
+x41A   => array(0x43A),
+x41B   => array(0x43B),
+x41C   => array(0x43C),
+x41D   => array(0x43D),
+x41E   => array(0x43E),
+x41F   => array(0x43F),
+x420   => array(0x440),
+x421   => array(0x441),
+x422   => array(0x442),
+x423   => array(0x443),
+x424   => array(0x444),
+x425   => array(0x445),
+x426   => array(0x446),
+x427   => array(0x447),
+x428   => array(0x448),
+x429   => array(0x449),
+x42A   => array(0x44A),
+x42B   => array(0x44B),
+x42C   => array(0x44C),
+x42D   => array(0x44D),
+x42E   => array(0x44E),
+x42F   => array(0x44F),
+x460   => array(0x461),
+x462   => array(0x463),
+x464   => array(0x465),
+x466   => array(0x467),
+x468   => array(0x469),
+x46A   => array(0x46B),
+x46C   => array(0x46D),
+x46E   => array(0x46F),
+x470   => array(0x471),
+x472   => array(0x473),
+x474   => array(0x475),
+x476   => array(0x477),
+x478   => array(0x479),
+x47A   => array(0x47B),
+x47C   => array(0x47D),
+x47E   => array(0x47F),
+x480   => array(0x481),
+x48A   => array(0x48B),
+x48C   => array(0x48D),
+x48E   => array(0x48F),
+x490   => array(0x491),
+x492   => array(0x493),
+x494   => array(0x495),
+x496   => array(0x497),
+x498   => array(0x499),
+x49A   => array(0x49B),
+x49C   => array(0x49D),
+x49E   => array(0x49F),
+x4A0   => array(0x4A1),
+x4A2   => array(0x4A3),
+x4A4   => array(0x4A5),
+x4A6   => array(0x4A7),
+x4A8   => array(0x4A9),
+x4AA   => array(0x4AB),
+x4AC   => array(0x4AD),
+x4AE   => array(0x4AF),
+x4B0   => array(0x4B1),
+x4B2   => array(0x4B3),
+x4B4   => array(0x4B5),
+x4B6   => array(0x4B7),
+x4B8   => array(0x4B9),
+x4BA   => array(0x4BB),
+x4BC   => array(0x4BD),
+x4BE   => array(0x4BF),
+x4C1   => array(0x4C2),
+x4C3   => array(0x4C4),
+x4C5   => array(0x4C6),
+x4C7   => array(0x4C8),
+x4C9   => array(0x4CA),
+x4CB   => array(0x4CC),
+x4CD   => array(0x4CE),
+x4D0   => array(0x4D1),
+x4D2   => array(0x4D3),
+x4D4   => array(0x4D5),
+x4D6   => array(0x4D7),
+x4D8   => array(0x4D9),
+x4DA   => array(0x4DB),
+x4DC   => array(0x4DD),
+x4DE   => array(0x4DF),
+x4E0   => array(0x4E1),
+x4E2   => array(0x4E3),
+x4E4   => array(0x4E5),
+x4E6   => array(0x4E7),
+x4E8   => array(0x4E9),
+x4EA   => array(0x4EB),
+x4EC   => array(0x4ED),
+x4EE   => array(0x4EF),
+x4F0   => array(0x4F1),
+x4F2   => array(0x4F3),
+x4F4   => array(0x4F5),
+x4F8   => array(0x4F9),
+x500   => array(0x501),
+x502   => array(0x503),
+x504   => array(0x505),
+x506   => array(0x507),
+x508   => array(0x509),
+x50A   => array(0x50B),
+x50C   => array(0x50D),
+x50E   => array(0x50F),
+x531   => array(0x561),
+x532   => array(0x562),
+x533   => array(0x563),
+x534   => array(0x564),
+x535   => array(0x565),
+x536   => array(0x566),
+x537   => array(0x567),
+x538   => array(0x568),
+x539   => array(0x569),
+x53A   => array(0x56A),
+x53B   => array(0x56B),
+x53C   => array(0x56C),
+x53D   => array(0x56D),
+x53E   => array(0x56E),
+x53F   => array(0x56F),
+x540   => array(0x570),
+x541   => array(0x571),
+x542   => array(0x572),
+x543   => array(0x573),
+x544   => array(0x574),
+x545   => array(0x575),
+x546   => array(0x576),
+x547   => array(0x577),
+x548   => array(0x578),
+x549   => array(0x579),
+x54A   => array(0x57A),
+x54B   => array(0x57B),
+x54C   => array(0x57C),
+x54D   => array(0x57D),
+x54E   => array(0x57E),
+x54F   => array(0x57F),
+x550   => array(0x580),
+x551   => array(0x581),
+x552   => array(0x582),
+x553   => array(0x583),
+x554   => array(0x584),
+x555   => array(0x585),
+x556   => array(0x586),
+x587   => array(0x565, 0x582),
+x1E00  => array(0x1E01),
+x1E02  => array(0x1E03),
+x1E04  => array(0x1E05),
+x1E06  => array(0x1E07),
+x1E08  => array(0x1E09),
+x1E0A  => array(0x1E0B),
+x1E0C  => array(0x1E0D),
+x1E0E  => array(0x1E0F),
+x1E10  => array(0x1E11),
+x1E12  => array(0x1E13),
+x1E14  => array(0x1E15),
+x1E16  => array(0x1E17),
+x1E18  => array(0x1E19),
+x1E1A  => array(0x1E1B),
+x1E1C  => array(0x1E1D),
+x1E1E  => array(0x1E1F),
+x1E20  => array(0x1E21),
+x1E22  => array(0x1E23),
+x1E24  => array(0x1E25),
+x1E26  => array(0x1E27),
+x1E28  => array(0x1E29),
+x1E2A  => array(0x1E2B),
+x1E2C  => array(0x1E2D),
+x1E2E  => array(0x1E2F),
+x1E30  => array(0x1E31),
+x1E32  => array(0x1E33),
+x1E34  => array(0x1E35),
+x1E36  => array(0x1E37),
+x1E38  => array(0x1E39),
+x1E3A  => array(0x1E3B),
+x1E3C  => array(0x1E3D),
+x1E3E  => array(0x1E3F),
+x1E40  => array(0x1E41),
+x1E42  => array(0x1E43),
+x1E44  => array(0x1E45),
+x1E46  => array(0x1E47),
+x1E48  => array(0x1E49),
+x1E4A  => array(0x1E4B),
+x1E4C  => array(0x1E4D),
+x1E4E  => array(0x1E4F),
+x1E50  => array(0x1E51),
+x1E52  => array(0x1E53),
+x1E54  => array(0x1E55),
+x1E56  => array(0x1E57),
+x1E58  => array(0x1E59),
+x1E5A  => array(0x1E5B),
+x1E5C  => array(0x1E5D),
+x1E5E  => array(0x1E5F),
+x1E60  => array(0x1E61),
+x1E62  => array(0x1E63),
+x1E64  => array(0x1E65),
+x1E66  => array(0x1E67),
+x1E68  => array(0x1E69),
+x1E6A  => array(0x1E6B),
+x1E6C  => array(0x1E6D),
+x1E6E  => array(0x1E6F),
+x1E70  => array(0x1E71),
+x1E72  => array(0x1E73),
+x1E74  => array(0x1E75),
+x1E76  => array(0x1E77),
+x1E78  => array(0x1E79),
+x1E7A  => array(0x1E7B),
+x1E7C  => array(0x1E7D),
+x1E7E  => array(0x1E7F),
+x1E80  => array(0x1E81),
+x1E82  => array(0x1E83),
+x1E84  => array(0x1E85),
+x1E86  => array(0x1E87),
+x1E88  => array(0x1E89),
+x1E8A  => array(0x1E8B),
+x1E8C  => array(0x1E8D),
+x1E8E  => array(0x1E8F),
+x1E90  => array(0x1E91),
+x1E92  => array(0x1E93),
+x1E94  => array(0x1E95),
+x1E96  => array(0x68, 0x331),
+x1E97  => array(0x74, 0x308),
+x1E98  => array(0x77, 0x30A),
+x1E99  => array(0x79, 0x30A),
+x1E9A  => array(0x61, 0x2BE),
+x1E9B  => array(0x1E61),
+x1EA0  => array(0x1EA1),
+x1EA2  => array(0x1EA3),
+x1EA4  => array(0x1EA5),
+x1EA6  => array(0x1EA7),
+x1EA8  => array(0x1EA9),
+x1EAA  => array(0x1EAB),
+x1EAC  => array(0x1EAD),
+x1EAE  => array(0x1EAF),
+x1EB0  => array(0x1EB1),
+x1EB2  => array(0x1EB3),
+x1EB4  => array(0x1EB5),
+x1EB6  => array(0x1EB7),
+x1EB8  => array(0x1EB9),
+x1EBA  => array(0x1EBB),
+x1EBC  => array(0x1EBD),
+x1EBE  => array(0x1EBF),
+x1EC0  => array(0x1EC1),
+x1EC2  => array(0x1EC3),
+x1EC4  => array(0x1EC5),
+x1EC6  => array(0x1EC7),
+x1EC8  => array(0x1EC9),
+x1ECA  => array(0x1ECB),
+x1ECC  => array(0x1ECD),
+x1ECE  => array(0x1ECF),
+x1ED0  => array(0x1ED1),
+x1ED2  => array(0x1ED3),
+x1ED4  => array(0x1ED5),
+x1ED6  => array(0x1ED7),
+x1ED8  => array(0x1ED9),
+x1EDA  => array(0x1EDB),
+x1EDC  => array(0x1EDD),
+x1EDE  => array(0x1EDF),
+x1EE0  => array(0x1EE1),
+x1EE2  => array(0x1EE3),
+x1EE4  => array(0x1EE5),
+x1EE6  => array(0x1EE7),
+x1EE8  => array(0x1EE9),
+x1EEA  => array(0x1EEB),
+x1EEC  => array(0x1EED),
+x1EEE  => array(0x1EEF),
+x1EF0  => array(0x1EF1),
+x1EF2  => array(0x1EF3),
+x1EF4  => array(0x1EF5),
+x1EF6  => array(0x1EF7),
+x1EF8  => array(0x1EF9),
+x1F08  => array(0x1F00),
+x1F09  => array(0x1F01),
+x1F0A  => array(0x1F02),
+x1F0B  => array(0x1F03),
+x1F0C  => array(0x1F04),
+x1F0D  => array(0x1F05),
+x1F0E  => array(0x1F06),
+x1F0F  => array(0x1F07),
+x1F18  => array(0x1F10),
+x1F19  => array(0x1F11),
+x1F1A  => array(0x1F12),
+x1F1B  => array(0x1F13),
+x1F1C  => array(0x1F14),
+x1F1D  => array(0x1F15),
+x1F28  => array(0x1F20),
+x1F29  => array(0x1F21),
+x1F2A  => array(0x1F22),
+x1F2B  => array(0x1F23),
+x1F2C  => array(0x1F24),
+x1F2D  => array(0x1F25),
+x1F2E  => array(0x1F26),
+x1F2F  => array(0x1F27),
+x1F38  => array(0x1F30),
+x1F39  => array(0x1F31),
+x1F3A  => array(0x1F32),
+x1F3B  => array(0x1F33),
+x1F3C  => array(0x1F34),
+x1F3D  => array(0x1F35),
+x1F3E  => array(0x1F36),
+x1F3F  => array(0x1F37),
+x1F48  => array(0x1F40),
+x1F49  => array(0x1F41),
+x1F4A  => array(0x1F42),
+x1F4B  => array(0x1F43),
+x1F4C  => array(0x1F44),
+x1F4D  => array(0x1F45),
+x1F50  => array(0x3C5, 0x313),
+x1F52  => array(0x3C5, 0x313, 0x300),
+x1F54  => array(0x3C5, 0x313, 0x301),
+x1F56  => array(0x3C5, 0x313, 0x342),
+x1F59  => array(0x1F51),
+x1F5B  => array(0x1F53),
+x1F5D  => array(0x1F55),
+x1F5F  => array(0x1F57),
+x1F68  => array(0x1F60),
+x1F69  => array(0x1F61),
+x1F6A  => array(0x1F62),
+x1F6B  => array(0x1F63),
+x1F6C  => array(0x1F64),
+x1F6D  => array(0x1F65),
+x1F6E  => array(0x1F66),
+x1F6F  => array(0x1F67),
+x1F80  => array(0x1F00, 0x3B9),
+x1F81  => array(0x1F01, 0x3B9),
+x1F82  => array(0x1F02, 0x3B9),
+x1F83  => array(0x1F03, 0x3B9),
+x1F84  => array(0x1F04, 0x3B9),
+x1F85  => array(0x1F05, 0x3B9),
+x1F86  => array(0x1F06, 0x3B9),
+x1F87  => array(0x1F07, 0x3B9),
+x1F88  => array(0x1F00, 0x3B9),
+x1F89  => array(0x1F01, 0x3B9),
+x1F8A  => array(0x1F02, 0x3B9),
+x1F8B  => array(0x1F03, 0x3B9),
+x1F8C  => array(0x1F04, 0x3B9),
+x1F8D  => array(0x1F05, 0x3B9),
+x1F8E  => array(0x1F06, 0x3B9),
+x1F8F  => array(0x1F07, 0x3B9),
+x1F90  => array(0x1F20, 0x3B9),
+x1F91  => array(0x1F21, 0x3B9),
+x1F92  => array(0x1F22, 0x3B9),
+x1F93  => array(0x1F23, 0x3B9),
+x1F94  => array(0x1F24, 0x3B9),
+x1F95  => array(0x1F25, 0x3B9),
+x1F96  => array(0x1F26, 0x3B9),
+x1F97  => array(0x1F27, 0x3B9),
+x1F98  => array(0x1F20, 0x3B9),
+x1F99  => array(0x1F21, 0x3B9),
+x1F9A  => array(0x1F22, 0x3B9),
+x1F9B  => array(0x1F23, 0x3B9),
+x1F9C  => array(0x1F24, 0x3B9),
+x1F9D  => array(0x1F25, 0x3B9),
+x1F9E  => array(0x1F26, 0x3B9),
+x1F9F  => array(0x1F27, 0x3B9),
+x1FA0  => array(0x1F60, 0x3B9),
+x1FA1  => array(0x1F61, 0x3B9),
+x1FA2  => array(0x1F62, 0x3B9),
+x1FA3  => array(0x1F63, 0x3B9),
+x1FA4  => array(0x1F64, 0x3B9),
+x1FA5  => array(0x1F65, 0x3B9),
+x1FA6  => array(0x1F66, 0x3B9),
+x1FA7  => array(0x1F67, 0x3B9),
+x1FA8  => array(0x1F60, 0x3B9),
+x1FA9  => array(0x1F61, 0x3B9),
+x1FAA  => array(0x1F62, 0x3B9),
+x1FAB  => array(0x1F63, 0x3B9),
+x1FAC  => array(0x1F64, 0x3B9),
+x1FAD  => array(0x1F65, 0x3B9),
+x1FAE  => array(0x1F66, 0x3B9),
+x1FAF  => array(0x1F67, 0x3B9),
+x1FB2  => array(0x1F70, 0x3B9),
+x1FB3  => array(0x3B1, 0x3B9),
+x1FB4  => array(0x3AC, 0x3B9),
+x1FB6  => array(0x3B1, 0x342),
+x1FB7  => array(0x3B1, 0x342, 0x3B9),
+x1FB8  => array(0x1FB0),
+x1FB9  => array(0x1FB1),
+x1FBA  => array(0x1F70),
+x1FBB  => array(0x1F71),
+x1FBC  => array(0x3B1, 0x3B9),
+x1FBE  => array(0x3B9),
+x1FC2  => array(0x1F74, 0x3B9),
+x1FC3  => array(0x3B7, 0x3B9),
+x1FC4  => array(0x3AE, 0x3B9),
+x1FC6  => array(0x3B7, 0x342),
+x1FC7  => array(0x3B7, 0x342, 0x3B9),
+x1FC8  => array(0x1F72),
+x1FC9  => array(0x1F73),
+x1FCA  => array(0x1F74),
+x1FCB  => array(0x1F75),
+x1FCC  => array(0x3B7, 0x3B9),
+x1FD2  => array(0x3B9, 0x308, 0x300),
+x1FD3  => array(0x3B9, 0x308, 0x301),
+x1FD6  => array(0x3B9, 0x342),
+x1FD7  => array(0x3B9, 0x308, 0x342),
+x1FD8  => array(0x1FD0),
+x1FD9  => array(0x1FD1),
+x1FDA  => array(0x1F76),
+x1FDB  => array(0x1F77),
+x1FE2  => array(0x3C5, 0x308, 0x300),
+x1FE3  => array(0x3C5, 0x308, 0x301),
+x1FE4  => array(0x3C1, 0x313),
+x1FE6  => array(0x3C5, 0x342),
+x1FE7  => array(0x3C5, 0x308, 0x342),
+x1FE8  => array(0x1FE0),
+x1FE9  => array(0x1FE1),
+x1FEA  => array(0x1F7A),
+x1FEB  => array(0x1F7B),
+x1FEC  => array(0x1FE5),
+x1FF2  => array(0x1F7C, 0x3B9),
+x1FF3  => array(0x3C9, 0x3B9),
+x1FF4  => array(0x3CE, 0x3B9),
+x1FF6  => array(0x3C9, 0x342),
+x1FF7  => array(0x3C9, 0x342, 0x3B9),
+x1FF8  => array(0x1F78),
+x1FF9  => array(0x1F79),
+x1FFA  => array(0x1F7C),
+x1FFB  => array(0x1F7D),
+x1FFC  => array(0x3C9, 0x3B9),
+x20A8  => array(0x72, 0x73),
+x2102  => array(0x63),
+x2103  => array(0xB0, 0x63),
+x2107  => array(0x25B),
+x2109  => array(0xB0, 0x66),
+x210B  => array(0x68),
+x210C  => array(0x68),
+x210D  => array(0x68),
+x2110  => array(0x69),
+x2111  => array(0x69),
+x2112  => array(0x6C),
+x2115  => array(0x6E),
+x2116  => array(0x6E, 0x6F),
+x2119  => array(0x70),
+x211A  => array(0x71),
+x211B  => array(0x72),
+x211C  => array(0x72),
+x211D  => array(0x72),
+x2120  => array(0x73, 0x6D),
+x2121  => array(0x74, 0x65, 0x6C),
+x2122  => array(0x74, 0x6D),
+x2124  => array(0x7A),
+x2126  => array(0x3C9),
+x2128  => array(0x7A),
+x212A  => array(0x6B),
+x212B  => array(0xE5),
+x212C  => array(0x62),
+x212D  => array(0x63),
+x2130  => array(0x65),
+x2131  => array(0x66),
+x2133  => array(0x6D),
+x213E  => array(0x3B3),
+x213F  => array(0x3C0),
+x2145  => array(0x64),
+x2160  => array(0x2170),
+x2161  => array(0x2171),
+x2162  => array(0x2172),
+x2163  => array(0x2173),
+x2164  => array(0x2174),
+x2165  => array(0x2175),
+x2166  => array(0x2176),
+x2167  => array(0x2177),
+x2168  => array(0x2178),
+x2169  => array(0x2179),
+x216A  => array(0x217A),
+x216B  => array(0x217B),
+x216C  => array(0x217C),
+x216D  => array(0x217D),
+x216E  => array(0x217E),
+x216F  => array(0x217F),
+x24B6  => array(0x24D0),
+x24B7  => array(0x24D1),
+x24B8  => array(0x24D2),
+x24B9  => array(0x24D3),
+x24BA  => array(0x24D4),
+x24BB  => array(0x24D5),
+x24BC  => array(0x24D6),
+x24BD  => array(0x24D7),
+x24BE  => array(0x24D8),
+x24BF  => array(0x24D9),
+x24C0  => array(0x24DA),
+x24C1  => array(0x24DB),
+x24C2  => array(0x24DC),
+x24C3  => array(0x24DD),
+x24C4  => array(0x24DE),
+x24C5  => array(0x24DF),
+x24C6  => array(0x24E0),
+x24C7  => array(0x24E1),
+x24C8  => array(0x24E2),
+x24C9  => array(0x24E3),
+x24CA  => array(0x24E4),
+x24CB  => array(0x24E5),
+x24CC  => array(0x24E6),
+x24CD  => array(0x24E7),
+x24CE  => array(0x24E8),
+x24CF  => array(0x24E9),
+x3371  => array(0x68, 0x70, 0x61),
+x3373  => array(0x61, 0x75),
+x3375  => array(0x6F, 0x76),
+x3380  => array(0x70, 0x61),
+x3381  => array(0x6E, 0x61),
+x3382  => array(0x3BC, 0x61),
+x3383  => array(0x6D, 0x61),
+x3384  => array(0x6B, 0x61),
+x3385  => array(0x6B, 0x62),
+x3386  => array(0x6D, 0x62),
+x3387  => array(0x67, 0x62),
+x338A  => array(0x70, 0x66),
+x338B  => array(0x6E, 0x66),
+x338C  => array(0x3BC, 0x66),
+x3390  => array(0x68, 0x7A),
+x3391  => array(0x6B, 0x68, 0x7A),
+x3392  => array(0x6D, 0x68, 0x7A),
+x3393  => array(0x67, 0x68, 0x7A),
+x3394  => array(0x74, 0x68, 0x7A),
+x33A9  => array(0x70, 0x61),
+x33AA  => array(0x6B, 0x70, 0x61),
+x33AB  => array(0x6D, 0x70, 0x61),
+x33AC  => array(0x67, 0x70, 0x61),
+x33B4  => array(0x70, 0x76),
+x33B5  => array(0x6E, 0x76),
+x33B6  => array(0x3BC, 0x76),
+x33B7  => array(0x6D, 0x76),
+x33B8  => array(0x6B, 0x76),
+x33B9  => array(0x6D, 0x76),
+x33BA  => array(0x70, 0x77),
+x33BB  => array(0x6E, 0x77),
+x33BC  => array(0x3BC, 0x77),
+x33BD  => array(0x6D, 0x77),
+x33BE  => array(0x6B, 0x77),
+x33BF  => array(0x6D, 0x77),
+x33C0  => array(0x6B, 0x3C9),
+x33C1  => array(0x6D, 0x3C9),
+        /* 0x33C2  => array(0x61, 0x2E, 0x6D, 0x2E), */
+x33C3  => array(0x62, 0x71),
+x33C6  => array(0x63, 0x2215, 0x6B, 0x67),
+x33C7  => array(0x63, 0x6F, 0x2E),
+x33C8  => array(0x64, 0x62),
+x33C9  => array(0x67, 0x79),
+x33CB  => array(0x68, 0x70),
+x33CD  => array(0x6B, 0x6B),
+x33CE  => array(0x6B, 0x6D),
+x33D7  => array(0x70, 0x68),
+x33D9  => array(0x70, 0x70, 0x6D),
+x33DA  => array(0x70, 0x72),
+x33DC  => array(0x73, 0x76),
+x33DD  => array(0x77, 0x62),
+xFB00  => array(0x66, 0x66),
+xFB01  => array(0x66, 0x69),
+xFB02  => array(0x66, 0x6C),
+xFB03  => array(0x66, 0x66, 0x69),
+xFB04  => array(0x66, 0x66, 0x6C),
+xFB05  => array(0x73, 0x74),
+xFB06  => array(0x73, 0x74),
+xFB13  => array(0x574, 0x576),
+xFB14  => array(0x574, 0x565),
+xFB15  => array(0x574, 0x56B),
+xFB16  => array(0x57E, 0x576),
+xFB17  => array(0x574, 0x56D),
+xFF21  => array(0xFF41),
+xFF22  => array(0xFF42),
+xFF23  => array(0xFF43),
+xFF24  => array(0xFF44),
+xFF25  => array(0xFF45),
+xFF26  => array(0xFF46),
+xFF27  => array(0xFF47),
+xFF28  => array(0xFF48),
+xFF29  => array(0xFF49),
+xFF2A  => array(0xFF4A),
+xFF2B  => array(0xFF4B),
+xFF2C  => array(0xFF4C),
+xFF2D  => array(0xFF4D),
+xFF2E  => array(0xFF4E),
+xFF2F  => array(0xFF4F),
+xFF30  => array(0xFF50),
+xFF31  => array(0xFF51),
+xFF32  => array(0xFF52),
+xFF33  => array(0xFF53),
+xFF34  => array(0xFF54),
+xFF35  => array(0xFF55),
+xFF36  => array(0xFF56),
+xFF37  => array(0xFF57),
+xFF38  => array(0xFF58),
+xFF39  => array(0xFF59),
+xFF3A  => array(0xFF5A),
+x10400 => array(0x10428),
+x10401 => array(0x10429),
+x10402 => array(0x1042A),
+x10403 => array(0x1042B),
+x10404 => array(0x1042C),
+x10405 => array(0x1042D),
+x10406 => array(0x1042E),
+x10407 => array(0x1042F),
+x10408 => array(0x10430),
+x10409 => array(0x10431),
+x1040A => array(0x10432),
+x1040B => array(0x10433),
+x1040C => array(0x10434),
+x1040D => array(0x10435),
+x1040E => array(0x10436),
+x1040F => array(0x10437),
+x10410 => array(0x10438),
+x10411 => array(0x10439),
+x10412 => array(0x1043A),
+x10413 => array(0x1043B),
+x10414 => array(0x1043C),
+x10415 => array(0x1043D),
+x10416 => array(0x1043E),
+x10417 => array(0x1043F),
+x10418 => array(0x10440),
+x10419 => array(0x10441),
+x1041A => array(0x10442),
+x1041B => array(0x10443),
+x1041C => array(0x10444),
+x1041D => array(0x10445),
+x1041E => array(0x10446),
+x1041F => array(0x10447),
+x10420 => array(0x10448),
+x10421 => array(0x10449),
+x10422 => array(0x1044A),
+x10423 => array(0x1044B),
+x10424 => array(0x1044C),
+x10425 => array(0x1044D),
+x1D400 => array(0x61),
+x1D401 => array(0x62),
+x1D402 => array(0x63),
+x1D403 => array(0x64),
+x1D404 => array(0x65),
+x1D405 => array(0x66),
+x1D406 => array(0x67),
+x1D407 => array(0x68),
+x1D408 => array(0x69),
+x1D409 => array(0x6A),
+x1D40A => array(0x6B),
+x1D40B => array(0x6C),
+x1D40C => array(0x6D),
+x1D40D => array(0x6E),
+x1D40E => array(0x6F),
+x1D40F => array(0x70),
+x1D410 => array(0x71),
+x1D411 => array(0x72),
+x1D412 => array(0x73),
+x1D413 => array(0x74),
+x1D414 => array(0x75),
+x1D415 => array(0x76),
+x1D416 => array(0x77),
+x1D417 => array(0x78),
+x1D418 => array(0x79),
+x1D419 => array(0x7A),
+x1D434 => array(0x61),
+x1D435 => array(0x62),
+x1D436 => array(0x63),
+x1D437 => array(0x64),
+x1D438 => array(0x65),
+x1D439 => array(0x66),
+x1D43A => array(0x67),
+x1D43B => array(0x68),
+x1D43C => array(0x69),
+x1D43D => array(0x6A),
+x1D43E => array(0x6B),
+x1D43F => array(0x6C),
+x1D440 => array(0x6D),
+x1D441 => array(0x6E),
+x1D442 => array(0x6F),
+x1D443 => array(0x70),
+x1D444 => array(0x71),
+x1D445 => array(0x72),
+x1D446 => array(0x73),
+x1D447 => array(0x74),
+x1D448 => array(0x75),
+x1D449 => array(0x76),
+x1D44A => array(0x77),
+x1D44B => array(0x78),
+x1D44C => array(0x79),
+x1D44D => array(0x7A),
+x1D468 => array(0x61),
+x1D469 => array(0x62),
+x1D46A => array(0x63),
+x1D46B => array(0x64),
+x1D46C => array(0x65),
+x1D46D => array(0x66),
+x1D46E => array(0x67),
+x1D46F => array(0x68),
+x1D470 => array(0x69),
+x1D471 => array(0x6A),
+x1D472 => array(0x6B),
+x1D473 => array(0x6C),
+x1D474 => array(0x6D),
+x1D475 => array(0x6E),
+x1D476 => array(0x6F),
+x1D477 => array(0x70),
+x1D478 => array(0x71),
+x1D479 => array(0x72),
+x1D47A => array(0x73),
+x1D47B => array(0x74),
+x1D47C => array(0x75),
+x1D47D => array(0x76),
+x1D47E => array(0x77),
+x1D47F => array(0x78),
+x1D480 => array(0x79),
+x1D481 => array(0x7A),
+x1D49C => array(0x61),
+x1D49E => array(0x63),
+x1D49F => array(0x64),
+x1D4A2 => array(0x67),
+x1D4A5 => array(0x6A),
+x1D4A6 => array(0x6B),
+x1D4A9 => array(0x6E),
+x1D4AA => array(0x6F),
+x1D4AB => array(0x70),
+x1D4AC => array(0x71),
+x1D4AE => array(0x73),
+x1D4AF => array(0x74),
+x1D4B0 => array(0x75),
+x1D4B1 => array(0x76),
+x1D4B2 => array(0x77),
+x1D4B3 => array(0x78),
+x1D4B4 => array(0x79),
+x1D4B5 => array(0x7A),
+x1D4D0 => array(0x61),
+x1D4D1 => array(0x62),
+x1D4D2 => array(0x63),
+x1D4D3 => array(0x64),
+x1D4D4 => array(0x65),
+x1D4D5 => array(0x66),
+x1D4D6 => array(0x67),
+x1D4D7 => array(0x68),
+x1D4D8 => array(0x69),
+x1D4D9 => array(0x6A),
+x1D4DA => array(0x6B),
+x1D4DB => array(0x6C),
+x1D4DC => array(0x6D),
+x1D4DD => array(0x6E),
+x1D4DE => array(0x6F),
+x1D4DF => array(0x70),
+x1D4E0 => array(0x71),
+x1D4E1 => array(0x72),
+x1D4E2 => array(0x73),
+x1D4E3 => array(0x74),
+x1D4E4 => array(0x75),
+x1D4E5 => array(0x76),
+x1D4E6 => array(0x77),
+x1D4E7 => array(0x78),
+x1D4E8 => array(0x79),
+x1D4E9 => array(0x7A),
+x1D504 => array(0x61),
+x1D505 => array(0x62),
+x1D507 => array(0x64),
+x1D508 => array(0x65),
+x1D509 => array(0x66),
+x1D50A => array(0x67),
+x1D50D => array(0x6A),
+x1D50E => array(0x6B),
+x1D50F => array(0x6C),
+x1D510 => array(0x6D),
+x1D511 => array(0x6E),
+x1D512 => array(0x6F),
+x1D513 => array(0x70),
+x1D514 => array(0x71),
+x1D516 => array(0x73),
+x1D517 => array(0x74),
+x1D518 => array(0x75),
+x1D519 => array(0x76),
+x1D51A => array(0x77),
+x1D51B => array(0x78),
+x1D51C => array(0x79),
+x1D538 => array(0x61),
+x1D539 => array(0x62),
+x1D53B => array(0x64),
+x1D53C => array(0x65),
+x1D53D => array(0x66),
+x1D53E => array(0x67),
+x1D540 => array(0x69),
+x1D541 => array(0x6A),
+x1D542 => array(0x6B),
+x1D543 => array(0x6C),
+x1D544 => array(0x6D),
+x1D546 => array(0x6F),
+x1D54A => array(0x73),
+x1D54B => array(0x74),
+x1D54C => array(0x75),
+x1D54D => array(0x76),
+x1D54E => array(0x77),
+x1D54F => array(0x78),
+x1D550 => array(0x79),
+x1D56C => array(0x61),
+x1D56D => array(0x62),
+x1D56E => array(0x63),
+x1D56F => array(0x64),
+x1D570 => array(0x65),
+x1D571 => array(0x66),
+x1D572 => array(0x67),
+x1D573 => array(0x68),
+x1D574 => array(0x69),
+x1D575 => array(0x6A),
+x1D576 => array(0x6B),
+x1D577 => array(0x6C),
+x1D578 => array(0x6D),
+x1D579 => array(0x6E),
+x1D57A => array(0x6F),
+x1D57B => array(0x70),
+x1D57C => array(0x71),
+x1D57D => array(0x72),
+x1D57E => array(0x73),
+x1D57F => array(0x74),
+x1D580 => array(0x75),
+x1D581 => array(0x76),
+x1D582 => array(0x77),
+x1D583 => array(0x78),
+x1D584 => array(0x79),
+x1D585 => array(0x7A),
+x1D5A0 => array(0x61),
+x1D5A1 => array(0x62),
+x1D5A2 => array(0x63),
+x1D5A3 => array(0x64),
+x1D5A4 => array(0x65),
+x1D5A5 => array(0x66),
+x1D5A6 => array(0x67),
+x1D5A7 => array(0x68),
+x1D5A8 => array(0x69),
+x1D5A9 => array(0x6A),
+x1D5AA => array(0x6B),
+x1D5AB => array(0x6C),
+x1D5AC => array(0x6D),
+x1D5AD => array(0x6E),
+x1D5AE => array(0x6F),
+x1D5AF => array(0x70),
+x1D5B0 => array(0x71),
+x1D5B1 => array(0x72),
+x1D5B2 => array(0x73),
+x1D5B3 => array(0x74),
+x1D5B4 => array(0x75),
+x1D5B5 => array(0x76),
+x1D5B6 => array(0x77),
+x1D5B7 => array(0x78),
+x1D5B8 => array(0x79),
+x1D5B9 => array(0x7A),
+x1D5D4 => array(0x61),
+x1D5D5 => array(0x62),
+x1D5D6 => array(0x63),
+x1D5D7 => array(0x64),
+x1D5D8 => array(0x65),
+x1D5D9 => array(0x66),
+x1D5DA => array(0x67),
+x1D5DB => array(0x68),
+x1D5DC => array(0x69),
+x1D5DD => array(0x6A),
+x1D5DE => array(0x6B),
+x1D5DF => array(0x6C),
+x1D5E0 => array(0x6D),
+x1D5E1 => array(0x6E),
+x1D5E2 => array(0x6F),
+x1D5E3 => array(0x70),
+x1D5E4 => array(0x71),
+x1D5E5 => array(0x72),
+x1D5E6 => array(0x73),
+x1D5E7 => array(0x74),
+x1D5E8 => array(0x75),
+x1D5E9 => array(0x76),
+x1D5EA => array(0x77),
+x1D5EB => array(0x78),
+x1D5EC => array(0x79),
+x1D5ED => array(0x7A),
+x1D608 => array(0x61),
+x1D609 => array(0x62),
+x1D60A => array(0x63),
+x1D60B => array(0x64),
+x1D60C => array(0x65),
+x1D60D => array(0x66),
+x1D60E => array(0x67),
+x1D60F => array(0x68),
+x1D610 => array(0x69),
+x1D611 => array(0x6A),
+x1D612 => array(0x6B),
+x1D613 => array(0x6C),
+x1D614 => array(0x6D),
+x1D615 => array(0x6E),
+x1D616 => array(0x6F),
+x1D617 => array(0x70),
+x1D618 => array(0x71),
+x1D619 => array(0x72),
+x1D61A => array(0x73),
+x1D61B => array(0x74),
+x1D61C => array(0x75),
+x1D61D => array(0x76),
+x1D61E => array(0x77),
+x1D61F => array(0x78),
+x1D620 => array(0x79),
+x1D621 => array(0x7A),
+x1D63C => array(0x61),
+x1D63D => array(0x62),
+x1D63E => array(0x63),
+x1D63F => array(0x64),
+x1D640 => array(0x65),
+x1D641 => array(0x66),
+x1D642 => array(0x67),
+x1D643 => array(0x68),
+x1D644 => array(0x69),
+x1D645 => array(0x6A),
+x1D646 => array(0x6B),
+x1D647 => array(0x6C),
+x1D648 => array(0x6D),
+x1D649 => array(0x6E),
+x1D64A => array(0x6F),
+x1D64B => array(0x70),
+x1D64C => array(0x71),
+x1D64D => array(0x72),
+x1D64E => array(0x73),
+x1D64F => array(0x74),
+x1D650 => array(0x75),
+x1D651 => array(0x76),
+x1D652 => array(0x77),
+x1D653 => array(0x78),
+x1D654 => array(0x79),
+x1D655 => array(0x7A),
+x1D670 => array(0x61),
+x1D671 => array(0x62),
+x1D672 => array(0x63),
+x1D673 => array(0x64),
+x1D674 => array(0x65),
+x1D675 => array(0x66),
+x1D676 => array(0x67),
+x1D677 => array(0x68),
+x1D678 => array(0x69),
+x1D679 => array(0x6A),
+x1D67A => array(0x6B),
+x1D67B => array(0x6C),
+x1D67C => array(0x6D),
+x1D67D => array(0x6E),
+x1D67E => array(0x6F),
+x1D67F => array(0x70),
+x1D680 => array(0x71),
+x1D681 => array(0x72),
+x1D682 => array(0x73),
+x1D683 => array(0x74),
+x1D684 => array(0x75),
+x1D685 => array(0x76),
+x1D686 => array(0x77),
+x1D687 => array(0x78),
+x1D688 => array(0x79),
+x1D689 => array(0x7A),
+x1D6A8 => array(0x3B1),
+x1D6A9 => array(0x3B2),
+x1D6AA => array(0x3B3),
+x1D6AB => array(0x3B4),
+x1D6AC => array(0x3B5),
+x1D6AD => array(0x3B6),
+x1D6AE => array(0x3B7),
+x1D6AF => array(0x3B8),
+x1D6B0 => array(0x3B9),
+x1D6B1 => array(0x3BA),
+x1D6B2 => array(0x3BB),
+x1D6B3 => array(0x3BC),
+x1D6B4 => array(0x3BD),
+x1D6B5 => array(0x3BE),
+x1D6B6 => array(0x3BF),
+x1D6B7 => array(0x3C0),
+x1D6B8 => array(0x3C1),
+x1D6B9 => array(0x3B8),
+x1D6BA => array(0x3C3),
+x1D6BB => array(0x3C4),
+x1D6BC => array(0x3C5),
+x1D6BD => array(0x3C6),
+x1D6BE => array(0x3C7),
+x1D6BF => array(0x3C8),
+x1D6C0 => array(0x3C9),
+x1D6D3 => array(0x3C3),
+x1D6E2 => array(0x3B1),
+x1D6E3 => array(0x3B2),
+x1D6E4 => array(0x3B3),
+x1D6E5 => array(0x3B4),
+x1D6E6 => array(0x3B5),
+x1D6E7 => array(0x3B6),
+x1D6E8 => array(0x3B7),
+x1D6E9 => array(0x3B8),
+x1D6EA => array(0x3B9),
+x1D6EB => array(0x3BA),
+x1D6EC => array(0x3BB),
+x1D6ED => array(0x3BC),
+x1D6EE => array(0x3BD),
+x1D6EF => array(0x3BE),
+x1D6F0 => array(0x3BF),
+x1D6F1 => array(0x3C0),
+x1D6F2 => array(0x3C1),
+x1D6F3 => array(0x3B8),
+x1D6F4 => array(0x3C3),
+x1D6F5 => array(0x3C4),
+x1D6F6 => array(0x3C5),
+x1D6F7 => array(0x3C6),
+x1D6F8 => array(0x3C7),
+x1D6F9 => array(0x3C8),
+x1D6FA => array(0x3C9),
+x1D70D => array(0x3C3),
+x1D71C => array(0x3B1),
+x1D71D => array(0x3B2),
+x1D71E => array(0x3B3),
+x1D71F => array(0x3B4),
+x1D720 => array(0x3B5),
+x1D721 => array(0x3B6),
+x1D722 => array(0x3B7),
+x1D723 => array(0x3B8),
+x1D724 => array(0x3B9),
+x1D725 => array(0x3BA),
+x1D726 => array(0x3BB),
+x1D727 => array(0x3BC),
+x1D728 => array(0x3BD),
+x1D729 => array(0x3BE),
+x1D72A => array(0x3BF),
+x1D72B => array(0x3C0),
+x1D72C => array(0x3C1),
+x1D72D => array(0x3B8),
+x1D72E => array(0x3C3),
+x1D72F => array(0x3C4),
+x1D730 => array(0x3C5),
+x1D731 => array(0x3C6),
+x1D732 => array(0x3C7),
+x1D733 => array(0x3C8),
+x1D734 => array(0x3C9),
+x1D747 => array(0x3C3),
+x1D756 => array(0x3B1),
+x1D757 => array(0x3B2),
+x1D758 => array(0x3B3),
+x1D759 => array(0x3B4),
+x1D75A => array(0x3B5),
+x1D75B => array(0x3B6),
+x1D75C => array(0x3B7),
+x1D75D => array(0x3B8),
+x1D75E => array(0x3B9),
+x1D75F => array(0x3BA),
+x1D760 => array(0x3BB),
+x1D761 => array(0x3BC),
+x1D762 => array(0x3BD),
+x1D763 => array(0x3BE),
+x1D764 => array(0x3BF),
+x1D765 => array(0x3C0),
+x1D766 => array(0x3C1),
+x1D767 => array(0x3B8),
+x1D768 => array(0x3C3),
+x1D769 => array(0x3C4),
+x1D76A => array(0x3C5),
+x1D76B => array(0x3C6),
+x1D76C => array(0x3C7),
+x1D76D => array(0x3C8),
+x1D76E => array(0x3C9),
+x1D781 => array(0x3C3),
+x1D790 => array(0x3B1),
+x1D791 => array(0x3B2),
+x1D792 => array(0x3B3),
+x1D793 => array(0x3B4),
+x1D794 => array(0x3B5),
+x1D795 => array(0x3B6),
+x1D796 => array(0x3B7),
+x1D797 => array(0x3B8),
+x1D798 => array(0x3B9),
+x1D799 => array(0x3BA),
+x1D79A => array(0x3BB),
+x1D79B => array(0x3BC),
+x1D79C => array(0x3BD),
+x1D79D => array(0x3BE),
+x1D79E => array(0x3BF),
+x1D79F => array(0x3C0),
+x1D7A0 => array(0x3C1),
+x1D7A1 => array(0x3B8),
+x1D7A2 => array(0x3C3),
+x1D7A3 => array(0x3C4),
+x1D7A4 => array(0x3C5),
+x1D7A5 => array(0x3C6),
+x1D7A6 => array(0x3C7),
+x1D7A7 => array(0x3C8),
+x1D7A8 => array(0x3C9),
+x1D7BB => array(0x3C3),
+x3F9   => array(0x3C3),
+x1D2C  => array(0x61),
+x1D2D  => array(0xE6),
+x1D2E  => array(0x62),
+x1D30  => array(0x64),
+x1D31  => array(0x65),
+x1D32  => array(0x1DD),
+x1D33  => array(0x67),
+x1D34  => array(0x68),
+x1D35  => array(0x69),
+x1D36  => array(0x6A),
+x1D37  => array(0x6B),
+x1D38  => array(0x6C),
+x1D39  => array(0x6D),
+x1D3A  => array(0x6E),
+x1D3C  => array(0x6F),
+x1D3D  => array(0x223),
+x1D3E  => array(0x70),
+x1D3F  => array(0x72),
+x1D40  => array(0x74),
+x1D41  => array(0x75),
+x1D42  => array(0x77),
+x213B  => array(0x66, 0x61, 0x78),
+x3250  => array(0x70, 0x74, 0x65),
+x32CC  => array(0x68, 0x67),
+x32CE  => array(0x65, 0x76),
+x32CF  => array(0x6C, 0x74, 0x64),
+x337A  => array(0x69, 0x75),
+x33DE  => array(0x76, 0x2215, 0x6D),
+x33DF  => array(0x61, 0x2215, 0x6D)
+    );
+    /**
+     * Normalization Combining Classes; Code Points not listed
+     * got Combining Class 0.
+     *
+     * @static
+     * @var array
+     * @access private
+     */
+    private static $_np_norm_combcls = array(
+x334   => 1,
+x335   => 1,
+x336   => 1,
+x337   => 1,
+x338   => 1,
+x93C   => 7,
+x9BC   => 7,
+xA3C   => 7,
+xABC   => 7,
+xB3C   => 7,
+xCBC   => 7,
+x1037  => 7,
+x3099  => 8,
+x309A  => 8,
+x94D   => 9,
+x9CD   => 9,
+xA4D   => 9,
+xACD   => 9,
+xB4D   => 9,
+xBCD   => 9,
+xC4D   => 9,
+xCCD   => 9,
+xD4D   => 9,
+xDCA   => 9,
+xE3A   => 9,
+xF84   => 9,
+x1039  => 9,
+x1714  => 9,
+x1734  => 9,
+x17D2  => 9,
+x5B0   => 10,
+x5B1   => 11,
+x5B2   => 12,
+x5B3   => 13,
+x5B4   => 14,
+x5B5   => 15,
+x5B6   => 16,
+x5B7   => 17,
+x5B8   => 18,
+x5B9   => 19,
+x5BB   => 20,
+x5Bc   => 21,
+x5BD   => 22,
+x5BF   => 23,
+x5C1   => 24,
+x5C2   => 25,
+xFB1E  => 26,
+x64B   => 27,
+x64C   => 28,
+x64D   => 29,
+x64E   => 30,
+x64F   => 31,
+x650   => 32,
+x651   => 33,
+x652   => 34,
+x670   => 35,
+x711   => 36,
+xC55   => 84,
+xC56   => 91,
+xE38   => 103,
+xE39   => 103,
+xE48   => 107,
+xE49   => 107,
+xE4A   => 107,
+xE4B   => 107,
+xEB8   => 118,
+xEB9   => 118,
+xEC8   => 122,
+xEC9   => 122,
+xECA   => 122,
+xECB   => 122,
+xF71   => 129,
+xF72   => 130,
+xF7A   => 130,
+xF7B   => 130,
+xF7C   => 130,
+xF7D   => 130,
+xF80   => 130,
+xF74   => 132,
+x321   => 202,
+x322   => 202,
+x327   => 202,
+x328   => 202,
+x31B   => 216,
+xF39   => 216,
+x1D165 => 216,
+x1D166 => 216,
+x1D16E => 216,
+x1D16F => 216,
+x1D170 => 216,
+x1D171 => 216,
+x1D172 => 216,
+x302A  => 218,
+x316   => 220,
+x317   => 220,
+x318   => 220,
+x319   => 220,
+x31C   => 220,
+x31D   => 220,
+x31E   => 220,
+x31F   => 220,
+x320   => 220,
+x323   => 220,
+x324   => 220,
+x325   => 220,
+x326   => 220,
+x329   => 220,
+x32A   => 220,
+x32B   => 220,
+x32C   => 220,
+x32D   => 220,
+x32E   => 220,
+x32F   => 220,
+x330   => 220,
+x331   => 220,
+x332   => 220,
+x333   => 220,
+x339   => 220,
+x33A   => 220,
+x33B   => 220,
+x33C   => 220,
+x347   => 220,
+x348   => 220,
+x349   => 220,
+x34D   => 220,
+x34E   => 220,
+x353   => 220,
+x354   => 220,
+x355   => 220,
+x356   => 220,
+x591   => 220,
+x596   => 220,
+x59B   => 220,
+x5A3   => 220,
+x5A4   => 220,
+x5A5   => 220,
+x5A6   => 220,
+x5A7   => 220,
+x5AA   => 220,
+x655   => 220,
+x656   => 220,
+x6E3   => 220,
+x6EA   => 220,
+x6ED   => 220,
+x731   => 220,
+x734   => 220,
+x737   => 220,
+x738   => 220,
+x739   => 220,
+x73B   => 220,
+x73C   => 220,
+x73E   => 220,
+x742   => 220,
+x744   => 220,
+x746   => 220,
+x748   => 220,
+x952   => 220,
+xF18   => 220,
+xF19   => 220,
+xF35   => 220,
+xF37   => 220,
+xFC6   => 220,
+x193B  => 220,
+x20E8  => 220,
+x1D17B => 220,
+x1D17C => 220,
+x1D17D => 220,
+x1D17E => 220,
+x1D17F => 220,
+x1D180 => 220,
+x1D181 => 220,
+x1D182 => 220,
+x1D18A => 220,
+x1D18B => 220,
+x59A   => 222,
+x5AD   => 222,
+x1929  => 222,
+x302D  => 222,
+x302E  => 224,
+x302F  => 224,
+x1D16D => 226,
+x5AE   => 228,
+x18A9  => 228,
+x302B  => 228,
+x300   => 230,
+x301   => 230,
+x302   => 230,
+x303   => 230,
+x304   => 230,
+x305   => 230,
+x306   => 230,
+x307   => 230,
+x308   => 230,
+x309   => 230,
+x30A   => 230,
+x30B   => 230,
+x30C   => 230,
+x30D   => 230,
+x30E   => 230,
+x30F   => 230,
+x310   => 230,
+x311   => 230,
+x312   => 230,
+x313   => 230,
+x314   => 230,
+x33D   => 230,
+x33E   => 230,
+x33F   => 230,
+x340   => 230,
+x341   => 230,
+x342   => 230,
+x343   => 230,
+x344   => 230,
+x346   => 230,
+x34A   => 230,
+x34B   => 230,
+x34C   => 230,
+x350   => 230,
+x351   => 230,
+x352   => 230,
+x357   => 230,
+x363   => 230,
+x364   => 230,
+x365   => 230,
+x366   => 230,
+x367   => 230,
+x368   => 230,
+x369   => 230,
+x36A   => 230,
+x36B   => 230,
+x36C   => 230,
+x36D   => 230,
+x36E   => 230,
+x36F   => 230,
+x483   => 230,
+x484   => 230,
+x485   => 230,
+x486   => 230,
+x592   => 230,
+x593   => 230,
+x594   => 230,
+x595   => 230,
+x597   => 230,
+x598   => 230,
+x599   => 230,
+x59C   => 230,
+x59D   => 230,
+x59E   => 230,
+x59F   => 230,
+x5A0   => 230,
+x5A1   => 230,
+x5A8   => 230,
+x5A9   => 230,
+x5AB   => 230,
+x5AC   => 230,
+x5AF   => 230,
+x5C4   => 230,
+x610   => 230,
+x611   => 230,
+x612   => 230,
+x613   => 230,
+x614   => 230,
+x615   => 230,
+x653   => 230,
+x654   => 230,
+x657   => 230,
+x658   => 230,
+x6D6   => 230,
+x6D7   => 230,
+x6D8   => 230,
+x6D9   => 230,
+x6DA   => 230,
+x6DB   => 230,
+x6DC   => 230,
+x6DF   => 230,
+x6E0   => 230,
+x6E1   => 230,
+x6E2   => 230,
+x6E4   => 230,
+x6E7   => 230,
+x6E8   => 230,
+x6EB   => 230,
+x6EC   => 230,
+x730   => 230,
+x732   => 230,
+x733   => 230,
+x735   => 230,
+x736   => 230,
+x73A   => 230,
+x73D   => 230,
+x73F   => 230,
+x740   => 230,
+x741   => 230,
+x743   => 230,
+x745   => 230,
+x747   => 230,
+x749   => 230,
+x74A   => 230,
+x951   => 230,
+x953   => 230,
+x954   => 230,
+xF82   => 230,
+xF83   => 230,
+xF86   => 230,
+xF87   => 230,
+x170D  => 230,
+x193A  => 230,
+x20D0  => 230,
+x20D1  => 230,
+x20D4  => 230,
+x20D5  => 230,
+x20D6  => 230,
+x20D7  => 230,
+x20DB  => 230,
+x20DC  => 230,
+x20E1  => 230,
+x20E7  => 230,
+x20E9  => 230,
+xFE20  => 230,
+xFE21  => 230,
+xFE22  => 230,
+xFE23  => 230,
+x1D185 => 230,
+x1D186 => 230,
+x1D187 => 230,
+x1D189 => 230,
+x1D188 => 230,
+x1D1AA => 230,
+x1D1AB => 230,
+x1D1AC => 230,
+x1D1AD => 230,
+x315   => 232,
+x31A   => 232,
+x302C  => 232,
+x35F   => 233,
+x362   => 233,
+x35D   => 234,
+x35E   => 234,
+x360   => 234,
+x361   => 234,
+x345   => 240
+    );
+    // }}}
+    // {{{ properties
+    /**
+     * @var string
+     * @access private
+     */
+    private $_punycode_prefix = 'xn--';
+    /**
+     * @access private
+     */
+    private $_invalid_ucs = 0x80000000;
+    /**
+     * @access private
+     */
+    private $_max_ucs = 0x10FFFF;
+    /**
+     * @var int
+     * @access private
+     */
+    private $_base = 36;
+    /**
+     * @var int
+     * @access private
+     */
+    private $_tmin = 1;
+    /**
+     * @var int
+     * @access private
+     */
+    private $_tmax = 26;
+    /**
+     * @var int
+     * @access private
+     */
+    private $_skew = 38;
+    /**
+     * @var int
+     * @access private
+     */
+    private $_damp = 700;
+    /**
+     * @var int
+     * @access private
+     */
+    private $_initial_bias = 72;
+    /**
+     * @var int
+     * @access private
+     */
+    private $_initial_n = 0x80;
+    /**
+     * @var int
+     * @access private
+     */
+    private $_slast;
+    /**
+     * @access private
+     */
+    private $_sbase = 0xAC00;
+    /**
+     * @access private
+     */
+    private $_lbase = 0x1100;
+    /**
+     * @access private
+     */
+    private $_vbase = 0x1161;
+    /**
+     * @access private
+     */
+    private $_tbase = 0x11a7;
+    /**
+     * @var int
+     * @access private
+     */
+    private $_lcount = 19;
+    /**
+     * @var int
+     * @access private
+     */
+    private $_vcount = 21;
+    /**
+     * @var int
+     * @access private
+     */
+    private $_tcount = 28;
+    /**
+     * vcount * tcount
+     *
+     * @var int
+     * @access private
+     */
+    private $_ncount = 588;
+    /**
+     * lcount * tcount * vcount
+     *
+     * @var int
+     * @access private
+     */
+    private $_scount = 11172;
+    /**
+     * Default encoding for encode()'s input and decode()'s output is UTF-8;
+     * Other possible encodings are ucs4_string and ucs4_array
+     * See {@link setParams()} for how to select these
+     *
+     * @var bool
+     * @access private
+     */
+    private $_api_encoding = 'utf8';
+    /**
+     * Overlong UTF-8 encodings are forbidden
+     *
+     * @var bool
+     * @access private
+     */
+    private $_allow_overlong = false;
+    /**
+     * Behave strict or not
+     *
+     * @var bool
+     * @access private
+     */
+    private $_strict_mode = false;
+    /**
+     * IDNA-version to use
+     *
+     * Values are "2003" and "2008".
+     * Defaults to "2003", since that was the original version and for
+     * compatibility with previous versions of this library.
+     * If you need to encode "new" characters like the German "Eszett",
+     * please switch to 2008 first before encoding.
+     *
+     * @var bool
+     * @access private
+     */
+    private $_version = '2003';
+    /**
+     * Cached value indicating whether or not mbstring function overloading is
+     * on for strlen
+     *
+     * This is cached for optimal performance.
+     *
+     * @var boolean
+     * @see Net_IDNA2::_byteLength()
+     */
+    private static $_mb_string_overload = null;
+    // }}}
+    // {{{ constructor
+    /**
+     * Constructor
+     *
+     * @param array $options Options to initialise the object with
+     *
+     * @access public
+     * @see    setParams()
+     */
+    public function __construct($options = null)
+    {
+        $this->_slast = $this->_sbase + $this->_lcount * $this->_vcount * $this->_tcount;
+        if (is_array($options)) {
+            $this->setParams($options);
+        }
+        // populate mbstring overloading cache if not set
+        if (self::$_mb_string_overload === null) {
+            self::$_mb_string_overload = (extension_loaded('mbstring')
+                && (ini_get('mbstring.func_overload') & 0x02) === 0x02);
+        }
+    }
+    // }}}
+    /**
+     * Sets a new option value. Available options and values:
+     *
+     * [utf8 -     Use either UTF-8 or ISO-8859-1 as input (true for UTF-8, false
+     *             otherwise); The output is always UTF-8]
+     * [overlong - Unicode does not allow unnecessarily long encodings of chars,
+     *             to allow this, set this parameter to true, else to false;
+     *             default is false.]
+     * [strict -   true: strict mode, good for registration purposes - Causes errors
+     *             on failures; false: loose mode, ideal for "wildlife" applications
+     *             by silently ignoring errors and returning the original input instead]
+     *
+     * @param mixed  $option Parameter to set (string: single parameter; array of Parameter => Value pairs)
+     * @param string $value  Value to use (if parameter 1 is a string)
+     *
+     * @return boolean       true on success, false otherwise
+     * @access public
+     */
+    public function setParams($option, $value = false)
+    {
+        if (!is_array($option)) {
+            $option = array($option => $value);
+        }
+        foreach ($option as $k => $v) {
+            switch ($k) {
+            case 'encoding':
+                switch ($v) {
+                case 'utf8':
+                case 'ucs4_string':
+                case 'ucs4_array':
+                    $this->_api_encoding = $v;
+                    break;
+                default:
+                    throw new InvalidArgumentException('Set Parameter: Unknown parameter '.$v.' for option '.$k);
+                }
+                break;
+            case 'overlong':
+                $this->_allow_overlong = ($v) ? true : false;
+                break;
+            case 'strict':
+                $this->_strict_mode = ($v) ? true : false;
+                break;
+            case 'version':
+                if (in_array($v, array('2003', '2008'))) {
+                    $this->_version = $v;
+                } else {
+                    throw new InvalidArgumentException('Set Parameter: Invalid parameter '.$v.' for option '.$k);
+                }
+                break;
+            default:
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Encode a given UTF-8 domain name.
+     *
+     * @param string $decoded           Domain name (UTF-8 or UCS-4)
+     * @param string $one_time_encoding Desired input encoding, see {@link set_parameter}
+     *                                  If not given will use default-encoding
+     *
+     * @return string Encoded Domain name (ACE string)
+     * @return mixed  processed string
+     * @throws Exception
+     * @access public
+     */
+    public function encode($decoded, $one_time_encoding = false)
+    {
+        // Forcing conversion of input to UCS4 array
+        // If one time encoding is given, use this, else the objects property
+        switch (($one_time_encoding) ? $one_time_encoding : $this->_api_encoding) {
+        case 'utf8':
+            $decoded = $this->_utf8_to_ucs4($decoded);
+            break;
+        case 'ucs4_string':
+            $decoded = $this->_ucs4_string_to_ucs4($decoded);
+        case 'ucs4_array': // No break; before this line. Catch case, but do nothing
+            break;
+        default:
+            throw new InvalidArgumentException('Unsupported input format');
+        }
+        // No input, no output, what else did you expect?
+        if (empty($decoded)) return '';
+        // Anchors for iteration
+        $last_begin = 0;
+        // Output string
+        $output = '';
+        foreach ($decoded as $k => $v) {
+            // Make sure to use just the plain dot
+            switch($v) {
+            case 0x3002:
+            case 0xFF0E:
+            case 0xFF61:
+                $decoded[$k] = 0x2E;
+                // It's right, no break here
+                // The codepoints above have to be converted to dots anyway
+            // Stumbling across an anchoring character
+            case 0x2E:
+            case 0x2F:
+            case 0x3A:
+            case 0x3F:
+            case 0x40:
+                // Neither email addresses nor URLs allowed in strict mode
+                if ($this->_strict_mode) {
+                    throw new InvalidArgumentException('Neither email addresses nor URLs are allowed in strict mode.');
+                }
+                // Skip first char
+                if ($k) {
+                    $encoded = '';
+                    $encoded = $this->_encode(array_slice($decoded, $last_begin, (($k)-$last_begin)));
+                    if ($encoded) {
+                        $output .= $encoded;
+                    } else {
+                        $output .= $this->_ucs4_to_utf8(array_slice($decoded, $last_begin, (($k)-$last_begin)));
+                    }
+                    $output .= chr($decoded[$k]);
+                }
+                $last_begin = $k + 1;
+            }
+        }
+        // Catch the rest of the string
+        if ($last_begin) {
+            $inp_len = sizeof($decoded);
+            $encoded = '';
+            $encoded = $this->_encode(array_slice($decoded, $last_begin, (($inp_len)-$last_begin)));
+            if ($encoded) {
+                $output .= $encoded;
+            } else {
+                $output .= $this->_ucs4_to_utf8(array_slice($decoded, $last_begin, (($inp_len)-$last_begin)));
+            }
+            return $output;
+        }
+        if ($output = $this->_encode($decoded)) {
+            return $output;
+        }
+        return $this->_ucs4_to_utf8($decoded);
+    }
+    /**
+     * Decode a given ACE domain name.
+     *
+     * @param string $input             Domain name (ACE string)
+     * @param string $one_time_encoding Desired output encoding, see {@link set_parameter}
+     *
+     * @return string                   Decoded Domain name (UTF-8 or UCS-4)
+     * @throws Exception
+     * @access public
+     */
+    public function decode($input, $one_time_encoding = false)
+    {
+        // Optionally set
+        if ($one_time_encoding) {
+            switch ($one_time_encoding) {
+            case 'utf8':
+            case 'ucs4_string':
+            case 'ucs4_array':
+                break;
+            default:
+                throw new InvalidArgumentException('Unknown encoding '.$one_time_encoding);
+            }
+        }
+        // Make sure to drop any newline characters around
+        $input = trim($input);
+        // Negotiate input and try to determine, wether it is a plain string,
+        // an email address or something like a complete URL
+        if (strpos($input, '@')) { // Maybe it is an email address
+            // No no in strict mode
+            if ($this->_strict_mode) {
+                throw new InvalidArgumentException('Only simple domain name parts can be handled in strict mode');
+            }
+            list($email_pref, $input) = explode('@', $input, 2);
+            $arr = explode('.', $input);
+            foreach ($arr as $k => $v) {
+                $conv = $this->_decode($v);
+                if ($conv) $arr[$k] = $conv;
+            }
+            $return = $email_pref . '@' . join('.', $arr);
+        } elseif (preg_match('![:\./]!', $input)) { // Or a complete domain name (with or without paths / parameters)
+            // No no in strict mode
+            if ($this->_strict_mode) {
+                throw new InvalidArgumentException('Only simple domain name parts can be handled in strict mode');
+            }
+            $parsed = parse_url($input);
+            if (isset($parsed['host'])) {
+                $arr = explode('.', $parsed['host']);
+                foreach ($arr as $k => $v) {
+                    $conv = $this->_decode($v);
+                    if ($conv) $arr[$k] = $conv;
+                }
+                $parsed['host'] = join('.', $arr);
+                if (isset($parsed['scheme'])) {
+                    $parsed['scheme'] .= (strtolower($parsed['scheme']) == 'mailto') ? ':' : '://';
+                }
+                $return = $this->_unparse_url($parsed);
+            } else { // parse_url seems to have failed, try without it
+                $arr = explode('.', $input);
+                foreach ($arr as $k => $v) {
+                    $conv = $this->_decode($v);
+                    if ($conv) $arr[$k] = $conv;
+                }
+                $return = join('.', $arr);
+            }
+        } else { // Otherwise we consider it being a pure domain name string
+            $return = $this->_decode($input);
+        }
+        // The output is UTF-8 by default, other output formats need conversion here
+        // If one time encoding is given, use this, else the objects property
+        switch (($one_time_encoding) ? $one_time_encoding : $this->_api_encoding) {
+        case 'utf8':
+            return $return;
+            break;
+        case 'ucs4_string':
+            return $this->_ucs4_to_ucs4_string($this->_utf8_to_ucs4($return));
+            break;
+        case 'ucs4_array':
+            return $this->_utf8_to_ucs4($return);
+            break;
+        default:
+            throw new InvalidArgumentException('Unsupported output format');
+        }
+    }
+    // {{{ private
+    /**
+     * Opposite function to parse_url()
+     *
+     * Inspired by code from comments of php.net-documentation for parse_url()
+     *
+     * @param array $parts_arr parts (strings) as returned by parse_url()
+     *
+     * @return string
+     * @access private
+     */
+    private function _unparse_url($parts_arr)
+    {
+        if (!empty($parts_arr['scheme'])) {
+            $ret_url = $parts_arr['scheme'];
+        }
+        if (!empty($parts_arr['user'])) {
+            $ret_url .= $parts_arr['user'];
+            if (!empty($parts_arr['pass'])) {
+                $ret_url .= ':' . $parts_arr['pass'];
+            }
+            $ret_url .= '@';
+        }
+        $ret_url .= $parts_arr['host'];
+        if (!empty($parts_arr['port'])) {
+            $ret_url .= ':' . $parts_arr['port'];
+        }
+        $ret_url .= $parts_arr['path'];
+        if (!empty($parts_arr['query'])) {
+            $ret_url .= '?' . $parts_arr['query'];
+        }
+        if (!empty($parts_arr['fragment'])) {
+            $ret_url .= '#' . $parts_arr['fragment'];
+        }
+        return $ret_url;
+    }
+    /**
+     * The actual encoding algorithm.
+     *
+     * @param string $decoded Decoded string which should be encoded
+     *
+     * @return string         Encoded string
+     * @throws Exception
+     * @access private
+     */
+    private function _encode($decoded)
+    {
+        // We cannot encode a domain name containing the Punycode prefix
+        $extract = self::_byteLength($this->_punycode_prefix);
+        $check_pref = $this->_utf8_to_ucs4($this->_punycode_prefix);
+        $check_deco = array_slice($decoded, 0, $extract);
+        if ($check_pref == $check_deco) {
+            throw new InvalidArgumentException('This is already a punycode string');
+        }
+        // We will not try to encode strings consisting of basic code points only
+        $encodable = false;
+        foreach ($decoded as $k => $v) {
+            if ($v > 0x7a) {
+                $encodable = true;
+                break;
+            }
+        }
+        if (!$encodable) {
+            if ($this->_strict_mode) {
+                throw new InvalidArgumentException('The given string does not contain encodable chars');
+            }
+            return false;
+        }
+        // Do NAMEPREP
+        $decoded = $this->_nameprep($decoded);
+        $deco_len = count($decoded);
+        // Empty array
+        if (!$deco_len) {
+            return false;
+        }
+        // How many chars have been consumed
+        $codecount = 0;
+        // Start with the prefix; copy it to output
+        $encoded = $this->_punycode_prefix;
+        $encoded = '';
+        // Copy all basic code points to output
+        for ($i = 0; $i < $deco_len; ++$i) {
+            $test = $decoded[$i];
+            // Will match [0-9a-zA-Z-]
+            if ((0x2F < $test && $test < 0x40)
+                || (0x40 < $test && $test < 0x5B)
+                || (0x60 < $test && $test <= 0x7B)
+                || (0x2D == $test)
+            ) {
+                $encoded .= chr($decoded[$i]);
+                $codecount++;
+            }
+        }
+        // All codepoints were basic ones
+        if ($codecount == $deco_len) {
+            return $encoded;
+        }
+        // Start with the prefix; copy it to output
+        $encoded = $this->_punycode_prefix . $encoded;
+        // If we have basic code points in output, add an hyphen to the end
+        if ($codecount) {
+            $encoded .= '-';
+        }
+        // Now find and encode all non-basic code points
+        $is_first  = true;
+        $cur_code  = $this->_initial_n;
+        $bias      = $this->_initial_bias;
+        $delta     = 0;
+        while ($codecount < $deco_len) {
+            // Find the smallest code point >= the current code point and
+            // remember the last ouccrence of it in the input
+            for ($i = 0, $next_code = $this->_max_ucs; $i < $deco_len; $i++) {
+                if ($decoded[$i] >= $cur_code && $decoded[$i] <= $next_code) {
+                    $next_code = $decoded[$i];
+                }
+            }
+            $delta += ($next_code - $cur_code) * ($codecount + 1);
+            $cur_code = $next_code;
+            // Scan input again and encode all characters whose code point is $cur_code
+            for ($i = 0; $i < $deco_len; $i++) {
+                if ($decoded[$i] < $cur_code) {
+                    $delta++;
+                } else if ($decoded[$i] == $cur_code) {
+                    for ($q = $delta, $k = $this->_base; 1; $k += $this->_base) {
+                        $t = ($k <= $bias)?
+                            $this->_tmin :
+                            (($k >= $bias + $this->_tmax)? $this->_tmax : $k - $bias);
+                        if ($q < $t) {
+                            break;
+                        }
+                        $encoded .= $this->_encodeDigit(ceil($t + (($q - $t) % ($this->_base - $t))));
+                        $q = ($q - $t) / ($this->_base - $t);
+                    }
+                    $encoded .= $this->_encodeDigit($q);
+                    $bias = $this->_adapt($delta, $codecount + 1, $is_first);
+                    $codecount++;
+                    $delta = 0;
+                    $is_first = false;
+                }
+            }
+            $delta++;
+            $cur_code++;
+        }
+        return $encoded;
+    }
+    /**
+     * The actual decoding algorithm.
+     *
+     * @param string $encoded Encoded string which should be decoded
+     *
+     * @return string         Decoded string
+     * @throws Exception
+     * @access private
+     */
+    private function _decode($encoded)
+    {
+        // We do need to find the Punycode prefix
+        if (!preg_match('!^' . preg_quote($this->_punycode_prefix, '!') . '!', $encoded)) {
+            return false;
+        }
+        $encode_test = preg_replace('!^' . preg_quote($this->_punycode_prefix, '!') . '!', '', $encoded);
+        // If nothing left after removing the prefix, it is hopeless
+        if (!$encode_test) {
+            return false;
+        }
+        // Find last occurence of the delimiter
+        $delim_pos = strrpos($encoded, '-');
+        if ($delim_pos > self::_byteLength($this->_punycode_prefix)) {
+            for ($k = self::_byteLength($this->_punycode_prefix); $k < $delim_pos; ++$k) {
+                $decoded[] = ord($encoded{$k});
+            }
+        } else {
+            $decoded = array();
+        }
+        $deco_len = count($decoded);
+        $enco_len = self::_byteLength($encoded);
+        // Wandering through the strings; init
+        $is_first = true;
+        $bias     = $this->_initial_bias;
+        $idx      = 0;
+        $char     = $this->_initial_n;
+        for ($enco_idx = ($delim_pos)? ($delim_pos + 1) : 0; $enco_idx < $enco_len; ++$deco_len) {
+            for ($old_idx = $idx, $w = 1, $k = $this->_base; 1 ; $k += $this->_base) {
+                $digit = $this->_decodeDigit($encoded{$enco_idx++});
+                $idx += $digit * $w;
+                $t = ($k <= $bias) ?
+                    $this->_tmin :
+                    (($k >= $bias + $this->_tmax)? $this->_tmax : ($k - $bias));
+                if ($digit < $t) {
+                    break;
+                }
+                $w = (int)($w * ($this->_base - $t));
+            }
+            $bias      = $this->_adapt($idx - $old_idx, $deco_len + 1, $is_first);
+            $is_first  = false;
+            $char     += (int) ($idx / ($deco_len + 1));
+            $idx      %= ($deco_len + 1);
+            if ($deco_len > 0) {
+                // Make room for the decoded char
+                for ($i = $deco_len; $i > $idx; $i--) {
+                    $decoded[$i] = $decoded[($i - 1)];
+                }
+            }
+            $decoded[$idx++] = $char;
+        }
+        return $this->_ucs4_to_utf8($decoded);
+    }
+    /**
+     * Adapt the bias according to the current code point and position.
+     *
+     * @param int     $delta    ...
+     * @param int     $npoints  ...
+     * @param boolean $is_first ...
+     *
+     * @return int
+     * @access private
+     */
+    private function _adapt($delta, $npoints, $is_first)
+    {
+        $delta = (int) ($is_first ? ($delta / $this->_damp) : ($delta / 2));
+        $delta += (int) ($delta / $npoints);
+        for ($k = 0; $delta > (($this->_base - $this->_tmin) * $this->_tmax) / 2; $k += $this->_base) {
+            $delta = (int) ($delta / ($this->_base - $this->_tmin));
+        }
+        return (int) ($k + ($this->_base - $this->_tmin + 1) * $delta / ($delta + $this->_skew));
+    }
+    /**
+     * Encoding a certain digit.
+     *
+     * @param int $d One digit to encode
+     *
+     * @return char  Encoded digit
+     * @access private
+     */
+    private function _encodeDigit($d)
+    {
+        return chr($d + 22 + 75 * ($d < 26));
+    }
+    /**
+     * Decode a certain digit.
+     *
+     * @param char $cp One digit (character) to decode
+     *
+     * @return int     Decoded digit
+     * @access private
+     */
+    private function _decodeDigit($cp)
+    {
+        $cp = ord($cp);
+        return ($cp - 48 < 10)? $cp - 22 : (($cp - 65 < 26)? $cp - 65 : (($cp - 97 < 26)? $cp - 97 : $this->_base));
+    }
+    /**
+     * Do Nameprep according to RFC3491 and RFC3454.
+     *
+     * @param array $input Unicode Characters
+     *
+     * @return string      Unicode Characters, Nameprep'd
+     * @throws Exception
+     * @access private
+     */
+    private function _nameprep($input)
+    {
+        $output = array();
+        // Walking through the input array, performing the required steps on each of
+        // the input chars and putting the result into the output array
+        // While mapping required chars we apply the cannonical ordering
+        foreach ($input as $v) {
+            // Map to nothing == skip that code point
+            if (in_array($v, self::$_np_map_nothing)) {
+                continue;
+            }
+            // Try to find prohibited input
+            if (in_array($v, self::$_np_prohibit) || in_array($v, self::$_general_prohibited)) {
+                throw new Net_IDNA2_Exception_Nameprep('Prohibited input U+' . sprintf('%08X', $v));
+            }
+            foreach (self::$_np_prohibit_ranges as $range) {
+                if ($range[0] <= $v && $v <= $range[1]) {
+                    throw new Net_IDNA2_Exception_Nameprep('Prohibited input U+' . sprintf('%08X', $v));
+                }
+            }
+            // Hangul syllable decomposition
+            if (0xAC00 <= $v && $v <= 0xD7AF) {
+                foreach ($this->_hangulDecompose($v) as $out) {
+                    $output[] = $out;
+                }
+            } else if (($this->_version == '2003') && isset(self::$_np_replacemaps[$v])) {
+                // There's a decomposition mapping for that code point
+                // Decompositions only in version 2003 (original) of IDNA
+                foreach ($this->_applyCannonicalOrdering(self::$_np_replacemaps[$v]) as $out) {
+                    $output[] = $out;
+                }
+            } else {
+                $output[] = $v;
+            }
+        }
+        // Combine code points
+        $last_class   = 0;
+        $last_starter = 0;
+        $out_len      = count($output);
+        for ($i = 0; $i < $out_len; ++$i) {
+            $class = $this->_getCombiningClass($output[$i]);
+            if ((!$last_class || $last_class != $class) && $class) {
+                // Try to match
+                $seq_len = $i - $last_starter;
+                $out = $this->_combine(array_slice($output, $last_starter, $seq_len));
+                // On match: Replace the last starter with the composed character and remove
+                // the now redundant non-starter(s)
+                if ($out) {
+                    $output[$last_starter] = $out;
+                    if (count($out) != $seq_len) {
+                        for ($j = $i + 1; $j < $out_len; ++$j) {
+                            $output[$j - 1] = $output[$j];
+                        }
+                        unset($output[$out_len]);
+                    }
+                    // Rewind the for loop by one, since there can be more possible compositions
+                    $i--;
+                    $out_len--;
+                    $last_class = ($i == $last_starter)? 0 : $this->_getCombiningClass($output[$i - 1]);
+                    continue;
+                }
+            }
+            // The current class is 0
+            if (!$class) {
+                $last_starter = $i;
+            }
+            $last_class = $class;
+        }
+        return $output;
+    }
+    /**
+     * Decomposes a Hangul syllable
+     * (see http://www.unicode.org/unicode/reports/tr15/#Hangul).
+     *
+     * @param integer $char 32bit UCS4 code point
+     *
+     * @return array        Either Hangul Syllable decomposed or original 32bit
+     *                      value as one value array
+     * @access private
+     */
+    private function _hangulDecompose($char)
+    {
+        $sindex = $char - $this->_sbase;
+        if ($sindex < 0 || $sindex >= $this->_scount) {
+            return array($char);
+        }
+        $result   = array();
+        $T        = $this->_tbase + $sindex % $this->_tcount;
+        $result[] = (int)($this->_lbase +  $sindex / $this->_ncount);
+        $result[] = (int)($this->_vbase + ($sindex % $this->_ncount) / $this->_tcount);
+        if ($T != $this->_tbase) {
+            $result[] = $T;
+        }
+        return $result;
+    }
+    /**
+     * Ccomposes a Hangul syllable
+     * (see http://www.unicode.org/unicode/reports/tr15/#Hangul).
+     *
+     * @param array $input Decomposed UCS4 sequence
+     *
+     * @return array       UCS4 sequence with syllables composed
+     * @access private
+     */
+    private function _hangulCompose($input)
+    {
+        $inp_len = count($input);
+        if (!$inp_len) {
+            return array();
+        }
+        $result   = array();
+        $last     = $input[0];
+        $result[] = $last; // copy first char from input to output
+        for ($i = 1; $i < $inp_len; ++$i) {
+            $char = $input[$i];
+            // Find out, wether two current characters from L and V
+            $lindex = $last - $this->_lbase;
+            if (0 <= $lindex && $lindex < $this->_lcount) {
+                $vindex = $char - $this->_vbase;
+                if (0 <= $vindex && $vindex < $this->_vcount) {
+                    // create syllable of form LV
+                    $last    = ($this->_sbase + ($lindex * $this->_vcount + $vindex) * $this->_tcount);
+                    $out_off = count($result) - 1;
+                    $result[$out_off] = $last; // reset last
+                    // discard char
+                    continue;
+                }
+            }
+            // Find out, wether two current characters are LV and T
+            $sindex = $last - $this->_sbase;
+            if (0 <= $sindex && $sindex < $this->_scount && ($sindex % $this->_tcount) == 0) {
+                $tindex = $char - $this->_tbase;
+                if (0 <= $tindex && $tindex <= $this->_tcount) {
+                    // create syllable of form LVT
+                    $last += $tindex;
+                    $out_off = count($result) - 1;
+                    $result[$out_off] = $last; // reset last
+                    // discard char
+                    continue;
+                }
+            }
+            // if neither case was true, just add the character
+            $last = $char;
+            $result[] = $char;
+        }
+        return $result;
+    }
+    /**
+     * Returns the combining class of a certain wide char.
+     *
+     * @param integer $char Wide char to check (32bit integer)
+     *
+     * @return integer      Combining class if found, else 0
+     * @access private
+     */
+    private function _getCombiningClass($char)
+    {
+        return isset(self::$_np_norm_combcls[$char])? self::$_np_norm_combcls[$char] : 0;
+    }
+    /**
+     * Apllies the cannonical ordering of a decomposed UCS4 sequence.
+     *
+     * @param array $input Decomposed UCS4 sequence
+     *
+     * @return array       Ordered USC4 sequence
+     * @access private
+     */
+    private function _applyCannonicalOrdering($input)
+    {
+        $swap = true;
+        $size = count($input);
+        while ($swap) {
+            $swap = false;
+            $last = $this->_getCombiningClass($input[0]);
+            for ($i = 0; $i < $size - 1; ++$i) {
+                $next = $this->_getCombiningClass($input[$i + 1]);
+                if ($next != 0 && $last > $next) {
+                    // Move item leftward until it fits
+                    for ($j = $i + 1; $j > 0; --$j) {
+                        if ($this->_getCombiningClass($input[$j - 1]) <= $next) {
+                            break;
+                        }
+                        $t = $input[$j];
+                        $input[$j] = $input[$j - 1];
+                        $input[$j - 1] = $t;
+                        $swap = 1;
+                    }
+                    // Reentering the loop looking at the old character again
+                    $next = $last;
+                }
+                $last = $next;
+            }
+        }
+        return $input;
+    }
+    /**
+     * Do composition of a sequence of starter and non-starter.
+     *
+     * @param array $input UCS4 Decomposed sequence
+     *
+     * @return array       Ordered USC4 sequence
+     * @access private
+     */
+    private function _combine($input)
+    {
+        $inp_len = count($input);
+        // Is it a Hangul syllable?
+        if (1 != $inp_len) {
+            $hangul = $this->_hangulCompose($input);
+            // This place is probably wrong
+            if (count($hangul) != $inp_len) {
+                return $hangul;
+            }
+        }
+        foreach (self::$_np_replacemaps as $np_src => $np_target) {
+            if ($np_target[0] != $input[0]) {
+                continue;
+            }
+            if (count($np_target) != $inp_len) {
+                continue;
+            }
+            $hit = false;
+            foreach ($input as $k2 => $v2) {
+                if ($v2 == $np_target[$k2]) {
+                    $hit = true;
+                } else {
+                    $hit = false;
+                    break;
+                }
+            }
+            if ($hit) {
+                return $np_src;
+            }
+        }
+        return false;
+    }
+    /**
+     * This converts an UTF-8 encoded string to its UCS-4 (array) representation
+     * By talking about UCS-4 we mean arrays of 32bit integers representing
+     * each of the "chars". This is due to PHP not being able to handle strings with
+     * bit depth different from 8. This applies to the reverse method _ucs4_to_utf8(), too.
+     * The following UTF-8 encodings are supported:
+     *
+     * bytes bits  representation
+     * 1        7  0xxxxxxx
+     * 2       11  110xxxxx 10xxxxxx
+     * 3       16  1110xxxx 10xxxxxx 10xxxxxx
+     * 4       21  11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+     * 5       26  111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
+     * 6       31  1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
+     *
+     * Each x represents a bit that can be used to store character data.
+     *
+     * @param string $input utf8-encoded string
+     *
+     * @return array        ucs4-encoded array
+     * @throws Exception
+     * @access private
+     */
+    private function _utf8_to_ucs4($input)
+    {
+        $output = array();
+        $out_len = 0;
+        $inp_len = self::_byteLength($input, '8bit');
+        $mode = 'next';
+        $test = 'none';
+        for ($k = 0; $k < $inp_len; ++$k) {
+            $v = ord($input{$k}); // Extract byte from input string
+            if ($v < 128) { // We found an ASCII char - put into stirng as is
+                $output[$out_len] = $v;
+                ++$out_len;
+                if ('add' == $mode) {
+                    throw new UnexpectedValueException('Conversion from UTF-8 to UCS-4 failed: malformed input at byte '.$k);
+                }
+                continue;
+            }
+            if ('next' == $mode) { // Try to find the next start byte; determine the width of the Unicode char
+                $start_byte = $v;
+                $mode = 'add';
+                $test = 'range';
+                if ($v >> 5 == 6) { // &110xxxxx 10xxxxx
+                    $next_byte = 0; // Tells, how many times subsequent bitmasks must rotate 6bits to the left
+                    $v = ($v - 192) << 6;
+                } elseif ($v >> 4 == 14) { // &1110xxxx 10xxxxxx 10xxxxxx
+                    $next_byte = 1;
+                    $v = ($v - 224) << 12;
+                } elseif ($v >> 3 == 30) { // &11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+                    $next_byte = 2;
+                    $v = ($v - 240) << 18;
+                } elseif ($v >> 2 == 62) { // &111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
+                    $next_byte = 3;
+                    $v = ($v - 248) << 24;
+                } elseif ($v >> 1 == 126) { // &1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
+                    $next_byte = 4;
+                    $v = ($v - 252) << 30;
+                } else {
+                    throw new UnexpectedValueException('This might be UTF-8, but I don\'t understand it at byte '.$k);
+                }
+                if ('add' == $mode) {
+                    $output[$out_len] = (int) $v;
+                    ++$out_len;
+                    continue;
+                }
+            }
+            if ('add' == $mode) {
+                if (!$this->_allow_overlong && $test == 'range') {
+                    $test = 'none';
+                    if (($v < 0xA0 && $start_byte == 0xE0) || ($v < 0x90 && $start_byte == 0xF0) || ($v > 0x8F && $start_byte == 0xF4)) {
+                        throw new OutOfRangeException('Bogus UTF-8 character detected (out of legal range) at byte '.$k);
+                    }
+                }
+                if ($v >> 6 == 2) { // Bit mask must be 10xxxxxx
+                    $v = ($v - 128) << ($next_byte * 6);
+                    $output[($out_len - 1)] += $v;
+                    --$next_byte;
+                } else {
+                    throw new UnexpectedValueException('Conversion from UTF-8 to UCS-4 failed: malformed input at byte '.$k);
+                }
+                if ($next_byte < 0) {
+                    $mode = 'next';
+                }
+            }
+        } // for
+        return $output;
+    }
+    /**
+     * Convert UCS-4 array into UTF-8 string
+     *
+     * @param array $input ucs4-encoded array
+     *
+     * @return string      utf8-encoded string
+     * @throws Exception
+     * @access private
+     */
+    private function _ucs4_to_utf8($input)
+    {
+        $output = '';
+        foreach ($input as $v) {
+            // $v = ord($v);
+            if ($v < 128) {
+                // 7bit are transferred literally
+                $output .= chr($v);
+            } else if ($v < 1 << 11) {
+                // 2 bytes
+                $output .= chr(192 + ($v >> 6))
+                    . chr(128 + ($v & 63));
+            } else if ($v < 1 << 16) {
+                // 3 bytes
+                $output .= chr(224 + ($v >> 12))
+                    . chr(128 + (($v >> 6) & 63))
+                    . chr(128 + ($v & 63));
+            } else if ($v < 1 << 21) {
+                // 4 bytes
+                $output .= chr(240 + ($v >> 18))
+                    . chr(128 + (($v >> 12) & 63))
+                    . chr(128 + (($v >>  6) & 63))
+                    . chr(128 + ($v & 63));
+            } else if ($v < 1 << 26) {
+                // 5 bytes
+                $output .= chr(248 + ($v >> 24))
+                    . chr(128 + (($v >> 18) & 63))
+                    . chr(128 + (($v >> 12) & 63))
+                    . chr(128 + (($v >>  6) & 63))
+                    . chr(128 + ($v & 63));
+            } else if ($v < 1 << 31) {
+                // 6 bytes
+                $output .= chr(252 + ($v >> 30))
+                    . chr(128 + (($v >> 24) & 63))
+                    . chr(128 + (($v >> 18) & 63))
+                    . chr(128 + (($v >> 12) & 63))
+                    . chr(128 + (($v >>  6) & 63))
+                    . chr(128 + ($v & 63));
+            } else {
+                throw new UnexpectedValueException('Conversion from UCS-4 to UTF-8 failed: malformed input');
+            }
+        }
+        return $output;
+    }
+    /**
+     * Convert UCS-4 array into UCS-4 string
+     *
+     * @param array $input ucs4-encoded array
+     *
+     * @return string      ucs4-encoded string
+     * @throws Exception
+     * @access private
+     */
+    private function _ucs4_to_ucs4_string($input)
+    {
+        $output = '';
+        // Take array values and split output to 4 bytes per value
+        // The bit mask is 255, which reads &11111111
+        foreach ($input as $v) {
+            $output .= ($v & (255 << 24) >> 24) . ($v & (255 << 16) >> 16) . ($v & (255 << 8) >> 8) . ($v & 255);
+        }
+        return $output;
+    }
+    /**
+     * Convert UCS-4 string into UCS-4 array
+     *
+     * @param string $input ucs4-encoded string
+     *
+     * @return array        ucs4-encoded array
+     * @throws InvalidArgumentException
+     * @access private
+     */
+    private function _ucs4_string_to_ucs4($input)
+    {
+        $output = array();
+        $inp_len = self::_byteLength($input);
+        // Input length must be dividable by 4
+        if ($inp_len % 4) {
+            throw new InvalidArgumentException('Input UCS4 string is broken');
+        }
+        // Empty input - return empty output
+        if (!$inp_len) {
+            return $output;
+        }
+        for ($i = 0, $out_len = -1; $i < $inp_len; ++$i) {
+            // Increment output position every 4 input bytes
+            if (!$i % 4) {
+                $out_len++;
+                $output[$out_len] = 0;
+            }
+            $output[$out_len] += ord($input{$i}) << (8 * (3 - ($i % 4) ) );
+        }
+        return $output;
+    }
+    /**
+     * Echo hex representation of UCS4 sequence.
+     *
+     * @param array   $input       UCS4 sequence
+     * @param boolean $include_bit Include bitmask in output
+     *
+     * @return void
+     * @static
+     * @access private
+     */
+    private static function _showHex($input, $include_bit = false)
+    {
+        foreach ($input as $k => $v) {
+            echo '[', $k, '] => ', sprintf('%X', $v);
+            if ($include_bit) {
+                echo ' (', Net_IDNA2::_showBitmask($v), ')';
+            }
+            echo "\n";
+        }
+    }
+    /**
+     * Gives you a bit representation of given Byte (8 bits), Word (16 bits) or DWord (32 bits)
+     * Output width is automagically determined
+     *
+     * @param int $octet ...
+     *
+     * @return string    Bitmask-representation
+     * @static
+     * @access private
+     */
+    private static function _showBitmask($octet)
+    {
+        if ($octet >= (1 << 16)) {
+            $w = 31;
+        } else if ($octet >= (1 << 8)) {
+            $w = 15;
+        } else {
+            $w = 7;
+        }
+        $return = '';
+        for ($i = $w; $i > -1; $i--) {
+            $return .= ($octet & (1 << $i))? '1' : '0';
+        }
+        return $return;
+    }
+    /**
+     * Gets the length of a string in bytes even if mbstring function
+     * overloading is turned on
+     *
+     * @param string $string the string for which to get the length.
+     *
+     * @return integer the length of the string in bytes.
+     *
+     * @see Net_IDNA2::$_mb_string_overload
+     */
+    private static function _byteLength($string)
+    {
+        if (self::$_mb_string_overload) {
+            return mb_strlen($string, '8bit');
+        }
+        return strlen((binary)$string);
+    }
+    // }}}}
+    // {{{ factory
+    /**
+     * Attempts to return a concrete IDNA instance for either php4 or php5.
+     *
+     * @param array $params Set of paramaters
+     *
+     * @return Net_IDNA2
+     * @access public
+     */
+    function getInstance($params = array())
+    {
+        return new Net_IDNA2($params);
+    }
+    // }}}
+    // {{{ singleton
+    /**
+     * Attempts to return a concrete IDNA instance for either php4 or php5,
+     * only creating a new instance if no IDNA instance with the same
+     * parameters currently exists.
+     *
+     * @param array $params Set of paramaters
+     *
+     * @return object Net_IDNA2
+     * @access public
+     */
+    function singleton($params = array())
+    {
+        static $instances;
+        if (!isset($instances)) {
+            $instances = array();
+        }
+        $signature = serialize($params);
+        if (!isset($instances[$signature])) {
+            $instances[$signature] = Net_IDNA2::getInstance($params);
+        }
+        return $instances[$signature];
+    }
+    // }}}
+}
+?>

new file wp-includes/pear-Net_IDNA2/IDNA2/Exception.php

diff --git a/wp-includes/pear-Net_IDNA2/IDNA2/Exception.php b/wp-includes/pear-Net_IDNA2/IDNA2/Exception.php
new file mode 100644
index 0000000..72cb1ae

-	+
	1	<?php
	2	class Net_IDNA2_Exception extends Exception
	3	{
	4	}

new file wp-includes/pear-Net_IDNA2/IDNA2/Exception/Nameprep.php

diff --git a/wp-includes/pear-Net_IDNA2/IDNA2/Exception/Nameprep.php b/wp-includes/pear-Net_IDNA2/IDNA2/Exception/Nameprep.php
new file mode 100644
index 0000000..b1d04b0

-	+
	1	<?php
	2	require_once ABSPATH . WPINC . '/pear-Net_IDNA2/IDNA2/Exception.php';
	3
	4	class Net_IDNA2_Exception_Nameprep extends Net_IDNA2_Exception
	5	{
	6	}

wp-includes/pluggable.php

diff --git a/wp-includes/pluggable.php b/wp-includes/pluggable.php
index f260296..48e2582 100644

  function wp_redirect($location, $status = 302) {
+ *
  * @since 2.3.0
+ *
+ * @uses Net_IDNA2
+ *
  * @return string redirect-sanitized URL
  **/
 function wp_sanitize_redirect($location) {
+        if(preg_match('|^https?://|i', $location)) {
+                require_once ABSPATH . WPINC . '/pear-Net_IDNA2/IDNA2.php';
+                $idna = Net_IDNA2::getInstance(array(
+                        'version' => '2008'
+                ));
+                $location = $idna->encode($location);
+        }
         $location = preg_replace('|[^a-z0-9-~+_.?#=&;,/:%!*]|i', '', $location);
         $location = wp_kses_no_null($location);

Trac UI Preferences

Download in other formats:

Original Format

Make WordPress Core

Context Navigation

Ticket #10690: 29170.2.diff

new file wp-includes/pear-Net_IDNA2/IDNA2.php

new file wp-includes/pear-Net_IDNA2/IDNA2/Exception.php

new file wp-includes/pear-Net_IDNA2/IDNA2/Exception/Nameprep.php

wp-includes/pluggable.php

Download in other formats: